]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3790 return wxPyTestDisplayAvailable();
3791 }
3792
3793 void wxApp_CleanUp() {
3794 __wxPyCleanup();
3795 }
3796
3797
3798 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3799
3800
3801
3802
3803
3804 SWIGINTERNINLINE PyObject *
3805 SWIG_FromCharPtr(const char *cptr)
3806 {
3807 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3808 }
3809
3810
3811 #if 0 // #ifdef __WXMAC__
3812
3813 // A dummy class that raises an exception if used...
3814 class wxEventLoop
3815 {
3816 public:
3817 wxEventLoop() { wxPyRaiseNotImplemented(); }
3818 int Run() { return 0; }
3819 void Exit(int rc = 0) {}
3820 bool Pending() const { return false; }
3821 bool Dispatch() { return false; }
3822 bool IsRunning() const { return false; }
3823 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3824 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3825 };
3826
3827 #else
3828
3829 #include <wx/evtloop.h>
3830
3831 #endif
3832
3833
3834
3835 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3836 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3837 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3838 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3839 wxWindowList& list = self->GetChildren();
3840 return wxPy_ConvertList(&list);
3841 }
3842 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863
3864 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3865 return wxWindow::FindWindowById(id, parent);
3866 }
3867
3868 wxWindow* wxFindWindowByName( const wxString& name,
3869 const wxWindow *parent = NULL ) {
3870 return wxWindow::FindWindowByName(name, parent);
3871 }
3872
3873 wxWindow* wxFindWindowByLabel( const wxString& label,
3874 const wxWindow *parent = NULL ) {
3875 return wxWindow::FindWindowByLabel(label, parent);
3876 }
3877
3878
3879 #ifdef __WXMSW__
3880 #include <wx/msw/private.h> // to get wxGetWindowId
3881 #endif
3882
3883
3884 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3885 #ifdef __WXMSW__
3886 WXHWND hWnd = (WXHWND)_hWnd;
3887 long id = wxGetWindowId(hWnd);
3888 wxWindow* win = new wxWindow;
3889 if (parent)
3890 parent->AddChild(win);
3891 win->SetEventHandler(win);
3892 win->SetHWND(hWnd);
3893 win->SetId(id);
3894 win->SubclassWin(hWnd);
3895 win->AdoptAttributesFromHWND();
3896 win->SetupColours();
3897 return win;
3898 #else
3899 wxPyRaiseNotImplemented();
3900 return NULL;
3901 #endif
3902 }
3903
3904
3905 PyObject* GetTopLevelWindows() {
3906 return wxPy_ConvertList(&wxTopLevelWindows);
3907 }
3908
3909
3910 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3911 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3913
3914 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3915
3916
3917 SWIGINTERNINLINE int
3918 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3919 {
3920 unsigned long v;
3921 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3922 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3923 return res;
3924 }
3925
3926 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3927 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3928 wxMenuItemList& list = self->GetMenuItems();
3929 return wxPy_ConvertList(&list);
3930 }
3931 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3932 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3933 static const wxString wxPyControlNameStr(wxControlNameStr);
3934 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3935 if (clientData) {
3936 wxPyClientData* data = new wxPyClientData(clientData);
3937 return self->Append(item, data);
3938 } else
3939 return self->Append(item);
3940 }
3941 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3942 if (clientData) {
3943 wxPyClientData* data = new wxPyClientData(clientData);
3944 return self->Insert(item, pos, data);
3945 } else
3946 return self->Insert(item, pos);
3947 }
3948 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3949 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3950 if (data) {
3951 Py_INCREF(data->m_obj);
3952 return data->m_obj;
3953 } else {
3954 Py_INCREF(Py_None);
3955 return Py_None;
3956 }
3957 }
3958 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 self->SetClientObject(n, data);
3961 }
3962
3963
3964 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3965 wxPyUserData* data = NULL;
3966 if ( userData ) {
3967 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3968 data = new wxPyUserData(userData);
3969 wxPyEndBlockThreads(blocked);
3970 }
3971 return new wxSizerItem(window, proportion, flag, border, data);
3972 }
3973 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3974 wxPyUserData* data = NULL;
3975 if ( userData ) {
3976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3977 data = new wxPyUserData(userData);
3978 wxPyEndBlockThreads(blocked);
3979 }
3980 return new wxSizerItem(width, height, proportion, flag, border, data);
3981 }
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(sizer, proportion, flag, border, data);
3990 }
3991
3992 SWIGINTERNINLINE PyObject *
3993 SWIG_From_float (float value)
3994 {
3995 return SWIG_From_double (value);
3996 }
3997
3998 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3999 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4000 if (data) {
4001 Py_INCREF(data->m_obj);
4002 return data->m_obj;
4003 } else {
4004 Py_INCREF(Py_None);
4005 return Py_None;
4006 }
4007 }
4008 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 self->SetUserData(data);
4016 }
4017
4018 // Figure out the type of the sizer item
4019
4020 struct wxPySizerItemInfo {
4021 wxPySizerItemInfo()
4022 : window(NULL), sizer(NULL), gotSize(false),
4023 size(wxDefaultSize), gotPos(false), pos(-1)
4024 {}
4025
4026 wxWindow* window;
4027 wxSizer* sizer;
4028 bool gotSize;
4029 wxSize size;
4030 bool gotPos;
4031 int pos;
4032 };
4033
4034 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4035
4036 wxPySizerItemInfo info;
4037 wxSize size;
4038 wxSize* sizePtr = &size;
4039
4040 // Find out what the type of the item is
4041 // try wxWindow
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4043 PyErr_Clear();
4044 info.window = NULL;
4045
4046 // try wxSizer
4047 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4048 PyErr_Clear();
4049 info.sizer = NULL;
4050
4051 // try wxSize or (w,h)
4052 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4053 info.size = *sizePtr;
4054 info.gotSize = true;
4055 }
4056
4057 // or a single int
4058 if (checkIdx && PyInt_Check(item)) {
4059 info.pos = PyInt_AsLong(item);
4060 info.gotPos = true;
4061 }
4062 }
4063 }
4064
4065 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4066 // no expected type, figure out what kind of error message to generate
4067 if ( !checkSize && !checkIdx )
4068 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4069 else if ( checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4071 else if ( !checkSize && checkIdx)
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4073 else
4074 // can this one happen?
4075 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4076 }
4077
4078 return info;
4079 }
4080
4081 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4082 if (!self->GetClientObject())
4083 self->SetClientObject(new wxPyOORClientData(_self));
4084 }
4085 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4086
4087 wxPyUserData* data = NULL;
4088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4089 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4090 if ( userData && (info.window || info.sizer || info.gotSize) )
4091 data = new wxPyUserData(userData);
4092 if ( info.sizer )
4093 PyObject_SetAttrString(item,"thisown",Py_False);
4094 wxPyEndBlockThreads(blocked);
4095
4096 // Now call the real Add method if a valid item type was found
4097 if ( info.window )
4098 return self->Add(info.window, proportion, flag, border, data);
4099 else if ( info.sizer )
4100 return self->Add(info.sizer, proportion, flag, border, data);
4101 else if (info.gotSize)
4102 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4103 proportion, flag, border, data);
4104 else
4105 return NULL;
4106 }
4107 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4108
4109 wxPyUserData* data = NULL;
4110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4111 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4112 if ( userData && (info.window || info.sizer || info.gotSize) )
4113 data = new wxPyUserData(userData);
4114 if ( info.sizer )
4115 PyObject_SetAttrString(item,"thisown",Py_False);
4116 wxPyEndBlockThreads(blocked);
4117
4118 // Now call the real Insert method if a valid item type was found
4119 if ( info.window )
4120 return self->Insert(before, info.window, proportion, flag, border, data);
4121 else if ( info.sizer )
4122 return self->Insert(before, info.sizer, proportion, flag, border, data);
4123 else if (info.gotSize)
4124 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4125 proportion, flag, border, data);
4126 else
4127 return NULL;
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Prepend method if a valid item type was found
4141 if ( info.window )
4142 return self->Prepend(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Prepend(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4153 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4154 wxPyEndBlockThreads(blocked);
4155 if ( info.window )
4156 return self->Remove(info.window);
4157 else if ( info.sizer )
4158 return self->Remove(info.sizer);
4159 else if ( info.gotPos )
4160 return self->Remove(info.pos);
4161 else
4162 return false;
4163 }
4164 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4166 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4167 wxPyEndBlockThreads(blocked);
4168 if ( info.window )
4169 return self->Detach(info.window);
4170 else if ( info.sizer )
4171 return self->Detach(info.sizer);
4172 else if ( info.gotPos )
4173 return self->Detach(info.pos);
4174 else
4175 return false;
4176 }
4177 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4180 wxPyEndBlockThreads(blocked);
4181 if ( info.window )
4182 return self->GetItem(info.window);
4183 else if ( info.sizer )
4184 return self->GetItem(info.sizer);
4185 else if ( info.gotPos )
4186 return self->GetItem(info.pos);
4187 else
4188 return NULL;
4189 }
4190 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4193 wxPyEndBlockThreads(blocked);
4194 if ( info.window )
4195 self->SetItemMinSize(info.window, size);
4196 else if ( info.sizer )
4197 self->SetItemMinSize(info.sizer, size);
4198 else if ( info.gotPos )
4199 self->SetItemMinSize(info.pos, size);
4200 }
4201 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4202 wxSizerItemList& list = self->GetChildren();
4203 return wxPy_ConvertList(&list);
4204 }
4205 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 return self->Show(info.window, show, recursive);
4211 else if ( info.sizer )
4212 return self->Show(info.sizer, show, recursive);
4213 else if ( info.gotPos )
4214 return self->Show(info.pos, show);
4215 else
4216 return false;
4217 }
4218 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4220 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4221 wxPyEndBlockThreads(blocked);
4222 if ( info.window )
4223 return self->IsShown(info.window);
4224 else if ( info.sizer )
4225 return self->IsShown(info.sizer);
4226 else if ( info.gotPos )
4227 return self->IsShown(info.pos);
4228 else
4229 return false;
4230 }
4231
4232 // See pyclasses.h
4233 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4234 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4235 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4236
4237
4238
4239
4240 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4241 {
4242 if (source == Py_None) {
4243 **obj = wxGBPosition(-1,-1);
4244 return true;
4245 }
4246 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4247 }
4248
4249 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4250 {
4251 if (source == Py_None) {
4252 **obj = wxGBSpan(-1,-1);
4253 return true;
4254 }
4255 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4256 }
4257
4258
4259 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4260 wxGBPosition temp, *obj = &temp;
4261 if ( other == Py_None ) return false;
4262 if ( ! wxGBPosition_helper(other, &obj) ) {
4263 PyErr_Clear();
4264 return false;
4265 }
4266 return self->operator==(*obj);
4267 }
4268 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4269 wxGBPosition temp, *obj = &temp;
4270 if ( other == Py_None ) return true;
4271 if ( ! wxGBPosition_helper(other, &obj)) {
4272 PyErr_Clear();
4273 return true;
4274 }
4275 return self->operator!=(*obj);
4276 }
4277 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4278 self->SetRow(row);
4279 self->SetCol(col);
4280 }
4281 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4283 PyObject* tup = PyTuple_New(2);
4284 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4285 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4286 wxPyEndBlockThreads(blocked);
4287 return tup;
4288 }
4289 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4290 wxGBSpan temp, *obj = &temp;
4291 if ( other == Py_None ) return false;
4292 if ( ! wxGBSpan_helper(other, &obj) ) {
4293 PyErr_Clear();
4294 return false;
4295 }
4296 return self->operator==(*obj);
4297 }
4298 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4299 wxGBSpan temp, *obj = &temp;
4300 if ( other == Py_None ) return true;
4301 if ( ! wxGBSpan_helper(other, &obj)) {
4302 PyErr_Clear();
4303 return true;
4304 }
4305 return self->operator!=(*obj);
4306 }
4307 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4308 self->SetRowspan(rowspan);
4309 self->SetColspan(colspan);
4310 }
4311 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 PyObject* tup = PyTuple_New(2);
4314 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4315 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4316 wxPyEndBlockThreads(blocked);
4317 return tup;
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(window, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4329 wxPyUserData* data = NULL;
4330 if ( userData ) {
4331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4332 data = new wxPyUserData(userData);
4333 wxPyEndBlockThreads(blocked);
4334 }
4335 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4347 int row, col;
4348 self->GetEndPos(row, col);
4349 return wxGBPosition(row, col);
4350 }
4351 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4352
4353 wxPyUserData* data = NULL;
4354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4355 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4356 if ( userData && (info.window || info.sizer || info.gotSize) )
4357 data = new wxPyUserData(userData);
4358 if ( info.sizer )
4359 PyObject_SetAttrString(item,"thisown",Py_False);
4360 wxPyEndBlockThreads(blocked);
4361
4362 // Now call the real Add method if a valid item type was found
4363 if ( info.window )
4364 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4365 else if ( info.sizer )
4366 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4367 else if (info.gotSize)
4368 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4369 pos, span, flag, border, data);
4370 return NULL;
4371 }
4372
4373
4374 #ifdef __cplusplus
4375 extern "C" {
4376 #endif
4377 SWIGINTERN int EmptyString_set(PyObject *) {
4378 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4379 return 1;
4380 }
4381
4382
4383 SWIGINTERN PyObject *EmptyString_get(void) {
4384 PyObject *pyobj = 0;
4385
4386 {
4387 #if wxUSE_UNICODE
4388 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4389 #else
4390 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #endif
4392 }
4393 return pyobj;
4394 }
4395
4396
4397 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4398 PyObject *resultobj = 0;
4399 wxObject *arg1 = (wxObject *) 0 ;
4400 wxString result;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4410 }
4411 arg1 = reinterpret_cast< wxObject * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = wxObject_GetClassName(arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 {
4419 #if wxUSE_UNICODE
4420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4421 #else
4422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4423 #endif
4424 }
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432 PyObject *resultobj = 0;
4433 wxObject *arg1 = (wxObject *) 0 ;
4434 void *argp1 = 0 ;
4435 int res1 = 0 ;
4436 PyObject *swig_obj[1] ;
4437
4438 if (!args) SWIG_fail;
4439 swig_obj[0] = args;
4440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4441 if (!SWIG_IsOK(res1)) {
4442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4443 }
4444 arg1 = reinterpret_cast< wxObject * >(argp1);
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 wxObject_Destroy(arg1);
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 resultobj = SWIG_Py_Void();
4452 return resultobj;
4453 fail:
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *obj;
4460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4461 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4462 return SWIG_Py_Void();
4463 }
4464
4465 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4466 PyObject *resultobj = 0;
4467 wxSize *arg1 = (wxSize *) 0 ;
4468 int arg2 ;
4469 void *argp1 = 0 ;
4470 int res1 = 0 ;
4471 int val2 ;
4472 int ecode2 = 0 ;
4473 PyObject *swig_obj[2] ;
4474
4475 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4477 if (!SWIG_IsOK(res1)) {
4478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4479 }
4480 arg1 = reinterpret_cast< wxSize * >(argp1);
4481 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4482 if (!SWIG_IsOK(ecode2)) {
4483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4484 }
4485 arg2 = static_cast< int >(val2);
4486 if (arg1) (arg1)->x = arg2;
4487
4488 resultobj = SWIG_Py_Void();
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4496 PyObject *resultobj = 0;
4497 wxSize *arg1 = (wxSize *) 0 ;
4498 int result;
4499 void *argp1 = 0 ;
4500 int res1 = 0 ;
4501 PyObject *swig_obj[1] ;
4502
4503 if (!args) SWIG_fail;
4504 swig_obj[0] = args;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4508 }
4509 arg1 = reinterpret_cast< wxSize * >(argp1);
4510 result = (int) ((arg1)->x);
4511 resultobj = SWIG_From_int(static_cast< int >(result));
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4519 PyObject *resultobj = 0;
4520 wxSize *arg1 = (wxSize *) 0 ;
4521 int arg2 ;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 int val2 ;
4525 int ecode2 = 0 ;
4526 PyObject *swig_obj[2] ;
4527
4528 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4532 }
4533 arg1 = reinterpret_cast< wxSize * >(argp1);
4534 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4535 if (!SWIG_IsOK(ecode2)) {
4536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4537 }
4538 arg2 = static_cast< int >(val2);
4539 if (arg1) (arg1)->y = arg2;
4540
4541 resultobj = SWIG_Py_Void();
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 PyObject *resultobj = 0;
4550 wxSize *arg1 = (wxSize *) 0 ;
4551 int result;
4552 void *argp1 = 0 ;
4553 int res1 = 0 ;
4554 PyObject *swig_obj[1] ;
4555
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4561 }
4562 arg1 = reinterpret_cast< wxSize * >(argp1);
4563 result = (int) ((arg1)->y);
4564 resultobj = SWIG_From_int(static_cast< int >(result));
4565 return resultobj;
4566 fail:
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4572 PyObject *resultobj = 0;
4573 int arg1 = (int) 0 ;
4574 int arg2 = (int) 0 ;
4575 wxSize *result = 0 ;
4576 int val1 ;
4577 int ecode1 = 0 ;
4578 int val2 ;
4579 int ecode2 = 0 ;
4580 PyObject * obj0 = 0 ;
4581 PyObject * obj1 = 0 ;
4582 char * kwnames[] = {
4583 (char *) "w",(char *) "h", NULL
4584 };
4585
4586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4587 if (obj0) {
4588 ecode1 = SWIG_AsVal_int(obj0, &val1);
4589 if (!SWIG_IsOK(ecode1)) {
4590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4591 }
4592 arg1 = static_cast< int >(val1);
4593 }
4594 if (obj1) {
4595 ecode2 = SWIG_AsVal_int(obj1, &val2);
4596 if (!SWIG_IsOK(ecode2)) {
4597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4598 }
4599 arg2 = static_cast< int >(val2);
4600 }
4601 {
4602 PyThreadState* __tstate = wxPyBeginAllowThreads();
4603 result = (wxSize *)new wxSize(arg1,arg2);
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4608 return resultobj;
4609 fail:
4610 return NULL;
4611 }
4612
4613
4614 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4615 PyObject *resultobj = 0;
4616 wxSize *arg1 = (wxSize *) 0 ;
4617 void *argp1 = 0 ;
4618 int res1 = 0 ;
4619 PyObject *swig_obj[1] ;
4620
4621 if (!args) SWIG_fail;
4622 swig_obj[0] = args;
4623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4626 }
4627 arg1 = reinterpret_cast< wxSize * >(argp1);
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 delete arg1;
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 resultobj = SWIG_Py_Void();
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 PyObject *arg2 = (PyObject *) 0 ;
4646 bool result;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "self",(char *) "other", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4657 if (!SWIG_IsOK(res1)) {
4658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4659 }
4660 arg1 = reinterpret_cast< wxSize * >(argp1);
4661 arg2 = obj1;
4662 {
4663 result = (bool)wxSize___eq__(arg1,arg2);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 {
4667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4668 }
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 wxSize *arg1 = (wxSize *) 0 ;
4678 PyObject *arg2 = (PyObject *) 0 ;
4679 bool result;
4680 void *argp1 = 0 ;
4681 int res1 = 0 ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 char * kwnames[] = {
4685 (char *) "self",(char *) "other", NULL
4686 };
4687
4688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4690 if (!SWIG_IsOK(res1)) {
4691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4692 }
4693 arg1 = reinterpret_cast< wxSize * >(argp1);
4694 arg2 = obj1;
4695 {
4696 result = (bool)wxSize___ne__(arg1,arg2);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 {
4700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4701 }
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 wxSize *arg1 = (wxSize *) 0 ;
4711 wxSize *arg2 = 0 ;
4712 wxSize result;
4713 void *argp1 = 0 ;
4714 int res1 = 0 ;
4715 wxSize temp2 ;
4716 PyObject * obj0 = 0 ;
4717 PyObject * obj1 = 0 ;
4718 char * kwnames[] = {
4719 (char *) "self",(char *) "sz", NULL
4720 };
4721
4722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4724 if (!SWIG_IsOK(res1)) {
4725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4726 }
4727 arg1 = reinterpret_cast< wxSize * >(argp1);
4728 {
4729 arg2 = &temp2;
4730 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4731 }
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (arg1)->operator +((wxSize const &)*arg2);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 wxSize *arg1 = (wxSize *) 0 ;
4748 wxSize *arg2 = 0 ;
4749 wxSize result;
4750 void *argp1 = 0 ;
4751 int res1 = 0 ;
4752 wxSize temp2 ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "self",(char *) "sz", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4761 if (!SWIG_IsOK(res1)) {
4762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4763 }
4764 arg1 = reinterpret_cast< wxSize * >(argp1);
4765 {
4766 arg2 = &temp2;
4767 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4768 }
4769 {
4770 PyThreadState* __tstate = wxPyBeginAllowThreads();
4771 result = (arg1)->operator -((wxSize const &)*arg2);
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj = 0;
4784 wxSize *arg1 = (wxSize *) 0 ;
4785 wxSize *arg2 = 0 ;
4786 void *argp1 = 0 ;
4787 int res1 = 0 ;
4788 wxSize temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char * kwnames[] = {
4792 (char *) "self",(char *) "sz", NULL
4793 };
4794
4795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4797 if (!SWIG_IsOK(res1)) {
4798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4799 }
4800 arg1 = reinterpret_cast< wxSize * >(argp1);
4801 {
4802 arg2 = &temp2;
4803 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4804 }
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 (arg1)->IncTo((wxSize const &)*arg2);
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_Py_Void();
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj = 0;
4820 wxSize *arg1 = (wxSize *) 0 ;
4821 wxSize *arg2 = 0 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char * kwnames[] = {
4828 (char *) "self",(char *) "sz", NULL
4829 };
4830
4831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4833 if (!SWIG_IsOK(res1)) {
4834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4835 }
4836 arg1 = reinterpret_cast< wxSize * >(argp1);
4837 {
4838 arg2 = &temp2;
4839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4840 }
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 (arg1)->DecTo((wxSize const &)*arg2);
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_Py_Void();
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj = 0;
4856 wxSize *arg1 = (wxSize *) 0 ;
4857 float arg2 ;
4858 float arg3 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 float val2 ;
4862 int ecode2 = 0 ;
4863 float val3 ;
4864 int ecode3 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 PyObject * obj2 = 0 ;
4868 char * kwnames[] = {
4869 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4870 };
4871
4872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4874 if (!SWIG_IsOK(res1)) {
4875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4876 }
4877 arg1 = reinterpret_cast< wxSize * >(argp1);
4878 ecode2 = SWIG_AsVal_float(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4881 }
4882 arg2 = static_cast< float >(val2);
4883 ecode3 = SWIG_AsVal_float(obj2, &val3);
4884 if (!SWIG_IsOK(ecode3)) {
4885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4886 }
4887 arg3 = static_cast< float >(val3);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 (arg1)->Scale(arg2,arg3);
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_Py_Void();
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 int arg2 ;
4905 int arg3 ;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 int val2 ;
4909 int ecode2 = 0 ;
4910 int val3 ;
4911 int ecode3 = 0 ;
4912 PyObject * obj0 = 0 ;
4913 PyObject * obj1 = 0 ;
4914 PyObject * obj2 = 0 ;
4915 char * kwnames[] = {
4916 (char *) "self",(char *) "w",(char *) "h", NULL
4917 };
4918
4919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4921 if (!SWIG_IsOK(res1)) {
4922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4923 }
4924 arg1 = reinterpret_cast< wxSize * >(argp1);
4925 ecode2 = SWIG_AsVal_int(obj1, &val2);
4926 if (!SWIG_IsOK(ecode2)) {
4927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4928 }
4929 arg2 = static_cast< int >(val2);
4930 ecode3 = SWIG_AsVal_int(obj2, &val3);
4931 if (!SWIG_IsOK(ecode3)) {
4932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4933 }
4934 arg3 = static_cast< int >(val3);
4935 {
4936 PyThreadState* __tstate = wxPyBeginAllowThreads();
4937 (arg1)->Set(arg2,arg3);
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 resultobj = SWIG_Py_Void();
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj = 0;
4950 wxSize *arg1 = (wxSize *) 0 ;
4951 int arg2 ;
4952 void *argp1 = 0 ;
4953 int res1 = 0 ;
4954 int val2 ;
4955 int ecode2 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 char * kwnames[] = {
4959 (char *) "self",(char *) "w", NULL
4960 };
4961
4962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4964 if (!SWIG_IsOK(res1)) {
4965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4966 }
4967 arg1 = reinterpret_cast< wxSize * >(argp1);
4968 ecode2 = SWIG_AsVal_int(obj1, &val2);
4969 if (!SWIG_IsOK(ecode2)) {
4970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4971 }
4972 arg2 = static_cast< int >(val2);
4973 {
4974 PyThreadState* __tstate = wxPyBeginAllowThreads();
4975 (arg1)->SetWidth(arg2);
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxSize *arg1 = (wxSize *) 0 ;
4989 int arg2 ;
4990 void *argp1 = 0 ;
4991 int res1 = 0 ;
4992 int val2 ;
4993 int ecode2 = 0 ;
4994 PyObject * obj0 = 0 ;
4995 PyObject * obj1 = 0 ;
4996 char * kwnames[] = {
4997 (char *) "self",(char *) "h", NULL
4998 };
4999
5000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5002 if (!SWIG_IsOK(res1)) {
5003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5004 }
5005 arg1 = reinterpret_cast< wxSize * >(argp1);
5006 ecode2 = SWIG_AsVal_int(obj1, &val2);
5007 if (!SWIG_IsOK(ecode2)) {
5008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5009 }
5010 arg2 = static_cast< int >(val2);
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 (arg1)->SetHeight(arg2);
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_Py_Void();
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 wxSize *arg1 = (wxSize *) 0 ;
5027 int result;
5028 void *argp1 = 0 ;
5029 int res1 = 0 ;
5030 PyObject *swig_obj[1] ;
5031
5032 if (!args) SWIG_fail;
5033 swig_obj[0] = args;
5034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5035 if (!SWIG_IsOK(res1)) {
5036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5037 }
5038 arg1 = reinterpret_cast< wxSize * >(argp1);
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (int)((wxSize const *)arg1)->GetWidth();
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 resultobj = SWIG_From_int(static_cast< int >(result));
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5053 PyObject *resultobj = 0;
5054 wxSize *arg1 = (wxSize *) 0 ;
5055 int result;
5056 void *argp1 = 0 ;
5057 int res1 = 0 ;
5058 PyObject *swig_obj[1] ;
5059
5060 if (!args) SWIG_fail;
5061 swig_obj[0] = args;
5062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)((wxSize const *)arg1)->GetHeight();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_From_int(static_cast< int >(result));
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 bool result;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087
5088 if (!args) SWIG_fail;
5089 swig_obj[0] = args;
5090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5091 if (!SWIG_IsOK(res1)) {
5092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5093 }
5094 arg1 = reinterpret_cast< wxSize * >(argp1);
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 wxSize *arg2 = 0 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 wxSize temp2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char * kwnames[] = {
5120 (char *) "self",(char *) "size", NULL
5121 };
5122
5123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5125 if (!SWIG_IsOK(res1)) {
5126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5127 }
5128 arg1 = reinterpret_cast< wxSize * >(argp1);
5129 {
5130 arg2 = &temp2;
5131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5132 }
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 (arg1)->SetDefaults((wxSize const &)*arg2);
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 PyObject *result = 0 ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 PyObject *swig_obj[1] ;
5153
5154 if (!args) SWIG_fail;
5155 swig_obj[0] = args;
5156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5157 if (!SWIG_IsOK(res1)) {
5158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5159 }
5160 arg1 = reinterpret_cast< wxSize * >(argp1);
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (PyObject *)wxSize_Get(arg1);
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 resultobj = result;
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 PyObject *obj;
5176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5177 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5178 return SWIG_Py_Void();
5179 }
5180
5181 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 return SWIG_Python_InitShadowInstance(args);
5183 }
5184
5185 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5186 PyObject *resultobj = 0;
5187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5188 double arg2 ;
5189 void *argp1 = 0 ;
5190 int res1 = 0 ;
5191 double val2 ;
5192 int ecode2 = 0 ;
5193 PyObject *swig_obj[2] ;
5194
5195 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5197 if (!SWIG_IsOK(res1)) {
5198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5199 }
5200 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5201 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5202 if (!SWIG_IsOK(ecode2)) {
5203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5204 }
5205 arg2 = static_cast< double >(val2);
5206 if (arg1) (arg1)->x = arg2;
5207
5208 resultobj = SWIG_Py_Void();
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5216 PyObject *resultobj = 0;
5217 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5218 double result;
5219 void *argp1 = 0 ;
5220 int res1 = 0 ;
5221 PyObject *swig_obj[1] ;
5222
5223 if (!args) SWIG_fail;
5224 swig_obj[0] = args;
5225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5226 if (!SWIG_IsOK(res1)) {
5227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5228 }
5229 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5230 result = (double) ((arg1)->x);
5231 resultobj = SWIG_From_double(static_cast< double >(result));
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5239 PyObject *resultobj = 0;
5240 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5241 double arg2 ;
5242 void *argp1 = 0 ;
5243 int res1 = 0 ;
5244 double val2 ;
5245 int ecode2 = 0 ;
5246 PyObject *swig_obj[2] ;
5247
5248 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5250 if (!SWIG_IsOK(res1)) {
5251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5252 }
5253 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5254 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5255 if (!SWIG_IsOK(ecode2)) {
5256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5257 }
5258 arg2 = static_cast< double >(val2);
5259 if (arg1) (arg1)->y = arg2;
5260
5261 resultobj = SWIG_Py_Void();
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5269 PyObject *resultobj = 0;
5270 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5271 double result;
5272 void *argp1 = 0 ;
5273 int res1 = 0 ;
5274 PyObject *swig_obj[1] ;
5275
5276 if (!args) SWIG_fail;
5277 swig_obj[0] = args;
5278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 result = (double) ((arg1)->y);
5284 resultobj = SWIG_From_double(static_cast< double >(result));
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 double arg1 = (double) 0.0 ;
5294 double arg2 = (double) 0.0 ;
5295 wxRealPoint *result = 0 ;
5296 double val1 ;
5297 int ecode1 = 0 ;
5298 double val2 ;
5299 int ecode2 = 0 ;
5300 PyObject * obj0 = 0 ;
5301 PyObject * obj1 = 0 ;
5302 char * kwnames[] = {
5303 (char *) "x",(char *) "y", NULL
5304 };
5305
5306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5307 if (obj0) {
5308 ecode1 = SWIG_AsVal_double(obj0, &val1);
5309 if (!SWIG_IsOK(ecode1)) {
5310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5311 }
5312 arg1 = static_cast< double >(val1);
5313 }
5314 if (obj1) {
5315 ecode2 = SWIG_AsVal_double(obj1, &val2);
5316 if (!SWIG_IsOK(ecode2)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5318 }
5319 arg2 = static_cast< double >(val2);
5320 }
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 PyObject *swig_obj[1] ;
5340
5341 if (!args) SWIG_fail;
5342 swig_obj[0] = args;
5343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5344 if (!SWIG_IsOK(res1)) {
5345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5346 }
5347 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 delete arg1;
5351
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 resultobj = SWIG_Py_Void();
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj = 0;
5364 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5365 PyObject *arg2 = (PyObject *) 0 ;
5366 bool result;
5367 void *argp1 = 0 ;
5368 int res1 = 0 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char * kwnames[] = {
5372 (char *) "self",(char *) "other", NULL
5373 };
5374
5375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5377 if (!SWIG_IsOK(res1)) {
5378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5379 }
5380 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5381 arg2 = obj1;
5382 {
5383 result = (bool)wxRealPoint___eq__(arg1,arg2);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 {
5387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5388 }
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj = 0;
5397 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5398 PyObject *arg2 = (PyObject *) 0 ;
5399 bool result;
5400 void *argp1 = 0 ;
5401 int res1 = 0 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char * kwnames[] = {
5405 (char *) "self",(char *) "other", NULL
5406 };
5407
5408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5412 }
5413 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5414 arg2 = obj1;
5415 {
5416 result = (bool)wxRealPoint___ne__(arg1,arg2);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5431 wxRealPoint *arg2 = 0 ;
5432 wxRealPoint result;
5433 void *argp1 = 0 ;
5434 int res1 = 0 ;
5435 wxRealPoint temp2 ;
5436 PyObject * obj0 = 0 ;
5437 PyObject * obj1 = 0 ;
5438 char * kwnames[] = {
5439 (char *) "self",(char *) "pt", NULL
5440 };
5441
5442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5444 if (!SWIG_IsOK(res1)) {
5445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5446 }
5447 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5455 wxPyEndAllowThreads(__tstate);
5456 if (PyErr_Occurred()) SWIG_fail;
5457 }
5458 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5459 return resultobj;
5460 fail:
5461 return NULL;
5462 }
5463
5464
5465 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5466 PyObject *resultobj = 0;
5467 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5468 wxRealPoint *arg2 = 0 ;
5469 wxRealPoint result;
5470 void *argp1 = 0 ;
5471 int res1 = 0 ;
5472 wxRealPoint temp2 ;
5473 PyObject * obj0 = 0 ;
5474 PyObject * obj1 = 0 ;
5475 char * kwnames[] = {
5476 (char *) "self",(char *) "pt", NULL
5477 };
5478
5479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5481 if (!SWIG_IsOK(res1)) {
5482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5483 }
5484 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5485 {
5486 arg2 = &temp2;
5487 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5488 }
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5503 PyObject *resultobj = 0;
5504 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5505 double arg2 ;
5506 double arg3 ;
5507 void *argp1 = 0 ;
5508 int res1 = 0 ;
5509 double val2 ;
5510 int ecode2 = 0 ;
5511 double val3 ;
5512 int ecode3 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 PyObject * obj2 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "x",(char *) "y", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 ecode2 = SWIG_AsVal_double(obj1, &val2);
5527 if (!SWIG_IsOK(ecode2)) {
5528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5529 }
5530 arg2 = static_cast< double >(val2);
5531 ecode3 = SWIG_AsVal_double(obj2, &val3);
5532 if (!SWIG_IsOK(ecode3)) {
5533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5534 }
5535 arg3 = static_cast< double >(val3);
5536 {
5537 PyThreadState* __tstate = wxPyBeginAllowThreads();
5538 wxRealPoint_Set(arg1,arg2,arg3);
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 resultobj = SWIG_Py_Void();
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5550 PyObject *resultobj = 0;
5551 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5552 PyObject *result = 0 ;
5553 void *argp1 = 0 ;
5554 int res1 = 0 ;
5555 PyObject *swig_obj[1] ;
5556
5557 if (!args) SWIG_fail;
5558 swig_obj[0] = args;
5559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5560 if (!SWIG_IsOK(res1)) {
5561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5562 }
5563 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (PyObject *)wxRealPoint_Get(arg1);
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = result;
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5578 PyObject *obj;
5579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5580 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5581 return SWIG_Py_Void();
5582 }
5583
5584 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 return SWIG_Python_InitShadowInstance(args);
5586 }
5587
5588 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590 wxPoint *arg1 = (wxPoint *) 0 ;
5591 int arg2 ;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 int val2 ;
5595 int ecode2 = 0 ;
5596 PyObject *swig_obj[2] ;
5597
5598 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5600 if (!SWIG_IsOK(res1)) {
5601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5602 }
5603 arg1 = reinterpret_cast< wxPoint * >(argp1);
5604 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5605 if (!SWIG_IsOK(ecode2)) {
5606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5607 }
5608 arg2 = static_cast< int >(val2);
5609 if (arg1) (arg1)->x = arg2;
5610
5611 resultobj = SWIG_Py_Void();
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5619 PyObject *resultobj = 0;
5620 wxPoint *arg1 = (wxPoint *) 0 ;
5621 int result;
5622 void *argp1 = 0 ;
5623 int res1 = 0 ;
5624 PyObject *swig_obj[1] ;
5625
5626 if (!args) SWIG_fail;
5627 swig_obj[0] = args;
5628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5629 if (!SWIG_IsOK(res1)) {
5630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5631 }
5632 arg1 = reinterpret_cast< wxPoint * >(argp1);
5633 result = (int) ((arg1)->x);
5634 resultobj = SWIG_From_int(static_cast< int >(result));
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 PyObject *resultobj = 0;
5643 wxPoint *arg1 = (wxPoint *) 0 ;
5644 int arg2 ;
5645 void *argp1 = 0 ;
5646 int res1 = 0 ;
5647 int val2 ;
5648 int ecode2 = 0 ;
5649 PyObject *swig_obj[2] ;
5650
5651 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5653 if (!SWIG_IsOK(res1)) {
5654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5655 }
5656 arg1 = reinterpret_cast< wxPoint * >(argp1);
5657 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5658 if (!SWIG_IsOK(ecode2)) {
5659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5660 }
5661 arg2 = static_cast< int >(val2);
5662 if (arg1) (arg1)->y = arg2;
5663
5664 resultobj = SWIG_Py_Void();
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5672 PyObject *resultobj = 0;
5673 wxPoint *arg1 = (wxPoint *) 0 ;
5674 int result;
5675 void *argp1 = 0 ;
5676 int res1 = 0 ;
5677 PyObject *swig_obj[1] ;
5678
5679 if (!args) SWIG_fail;
5680 swig_obj[0] = args;
5681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5682 if (!SWIG_IsOK(res1)) {
5683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5684 }
5685 arg1 = reinterpret_cast< wxPoint * >(argp1);
5686 result = (int) ((arg1)->y);
5687 resultobj = SWIG_From_int(static_cast< int >(result));
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj = 0;
5696 int arg1 = (int) 0 ;
5697 int arg2 = (int) 0 ;
5698 wxPoint *result = 0 ;
5699 int val1 ;
5700 int ecode1 = 0 ;
5701 int val2 ;
5702 int ecode2 = 0 ;
5703 PyObject * obj0 = 0 ;
5704 PyObject * obj1 = 0 ;
5705 char * kwnames[] = {
5706 (char *) "x",(char *) "y", NULL
5707 };
5708
5709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5710 if (obj0) {
5711 ecode1 = SWIG_AsVal_int(obj0, &val1);
5712 if (!SWIG_IsOK(ecode1)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5714 }
5715 arg1 = static_cast< int >(val1);
5716 }
5717 if (obj1) {
5718 ecode2 = SWIG_AsVal_int(obj1, &val2);
5719 if (!SWIG_IsOK(ecode2)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5721 }
5722 arg2 = static_cast< int >(val2);
5723 }
5724 {
5725 PyThreadState* __tstate = wxPyBeginAllowThreads();
5726 result = (wxPoint *)new wxPoint(arg1,arg2);
5727 wxPyEndAllowThreads(__tstate);
5728 if (PyErr_Occurred()) SWIG_fail;
5729 }
5730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 PyObject *swig_obj[1] ;
5743
5744 if (!args) SWIG_fail;
5745 swig_obj[0] = args;
5746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5747 if (!SWIG_IsOK(res1)) {
5748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5749 }
5750 arg1 = reinterpret_cast< wxPoint * >(argp1);
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 delete arg1;
5754
5755 wxPyEndAllowThreads(__tstate);
5756 if (PyErr_Occurred()) SWIG_fail;
5757 }
5758 resultobj = SWIG_Py_Void();
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5766 PyObject *resultobj = 0;
5767 wxPoint *arg1 = (wxPoint *) 0 ;
5768 PyObject *arg2 = (PyObject *) 0 ;
5769 bool result;
5770 void *argp1 = 0 ;
5771 int res1 = 0 ;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 char * kwnames[] = {
5775 (char *) "self",(char *) "other", NULL
5776 };
5777
5778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 arg2 = obj1;
5785 {
5786 result = (bool)wxPoint___eq__(arg1,arg2);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 {
5790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5791 }
5792 return resultobj;
5793 fail:
5794 return NULL;
5795 }
5796
5797
5798 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5799 PyObject *resultobj = 0;
5800 wxPoint *arg1 = (wxPoint *) 0 ;
5801 PyObject *arg2 = (PyObject *) 0 ;
5802 bool result;
5803 void *argp1 = 0 ;
5804 int res1 = 0 ;
5805 PyObject * obj0 = 0 ;
5806 PyObject * obj1 = 0 ;
5807 char * kwnames[] = {
5808 (char *) "self",(char *) "other", NULL
5809 };
5810
5811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5813 if (!SWIG_IsOK(res1)) {
5814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5815 }
5816 arg1 = reinterpret_cast< wxPoint * >(argp1);
5817 arg2 = obj1;
5818 {
5819 result = (bool)wxPoint___ne__(arg1,arg2);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5824 }
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj = 0;
5833 wxPoint *arg1 = (wxPoint *) 0 ;
5834 wxPoint *arg2 = 0 ;
5835 wxPoint result;
5836 void *argp1 = 0 ;
5837 int res1 = 0 ;
5838 wxPoint temp2 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 char * kwnames[] = {
5842 (char *) "self",(char *) "pt", NULL
5843 };
5844
5845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5847 if (!SWIG_IsOK(res1)) {
5848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5849 }
5850 arg1 = reinterpret_cast< wxPoint * >(argp1);
5851 {
5852 arg2 = &temp2;
5853 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5854 }
5855 {
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 result = (arg1)->operator +((wxPoint const &)*arg2);
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5862 return resultobj;
5863 fail:
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxPoint *arg1 = (wxPoint *) 0 ;
5871 wxPoint *arg2 = 0 ;
5872 wxPoint result;
5873 void *argp1 = 0 ;
5874 int res1 = 0 ;
5875 wxPoint temp2 ;
5876 PyObject * obj0 = 0 ;
5877 PyObject * obj1 = 0 ;
5878 char * kwnames[] = {
5879 (char *) "self",(char *) "pt", NULL
5880 };
5881
5882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5884 if (!SWIG_IsOK(res1)) {
5885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5886 }
5887 arg1 = reinterpret_cast< wxPoint * >(argp1);
5888 {
5889 arg2 = &temp2;
5890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5891 }
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 result = (arg1)->operator -((wxPoint const &)*arg2);
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj = 0;
5907 wxPoint *arg1 = (wxPoint *) 0 ;
5908 wxPoint *arg2 = 0 ;
5909 wxPoint *result = 0 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 wxPoint temp2 ;
5913 PyObject * obj0 = 0 ;
5914 PyObject * obj1 = 0 ;
5915 char * kwnames[] = {
5916 (char *) "self",(char *) "pt", NULL
5917 };
5918
5919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5921 if (!SWIG_IsOK(res1)) {
5922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5923 }
5924 arg1 = reinterpret_cast< wxPoint * >(argp1);
5925 {
5926 arg2 = &temp2;
5927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5928 }
5929 {
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 {
5932 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5933 result = (wxPoint *) &_result_ref;
5934 }
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 wxPoint *arg2 = 0 ;
5949 wxPoint *result = 0 ;
5950 void *argp1 = 0 ;
5951 int res1 = 0 ;
5952 wxPoint temp2 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "pt", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 {
5966 arg2 = &temp2;
5967 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5968 }
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 {
5972 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5973 result = (wxPoint *) &_result_ref;
5974 }
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj = 0;
5987 wxPoint *arg1 = (wxPoint *) 0 ;
5988 long arg2 ;
5989 long arg3 ;
5990 void *argp1 = 0 ;
5991 int res1 = 0 ;
5992 long val2 ;
5993 int ecode2 = 0 ;
5994 long val3 ;
5995 int ecode3 = 0 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 PyObject * obj2 = 0 ;
5999 char * kwnames[] = {
6000 (char *) "self",(char *) "x",(char *) "y", NULL
6001 };
6002
6003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6005 if (!SWIG_IsOK(res1)) {
6006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6007 }
6008 arg1 = reinterpret_cast< wxPoint * >(argp1);
6009 ecode2 = SWIG_AsVal_long(obj1, &val2);
6010 if (!SWIG_IsOK(ecode2)) {
6011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6012 }
6013 arg2 = static_cast< long >(val2);
6014 ecode3 = SWIG_AsVal_long(obj2, &val3);
6015 if (!SWIG_IsOK(ecode3)) {
6016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6017 }
6018 arg3 = static_cast< long >(val3);
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 wxPoint_Set(arg1,arg2,arg3);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 resultobj = SWIG_Py_Void();
6026 return resultobj;
6027 fail:
6028 return NULL;
6029 }
6030
6031
6032 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6033 PyObject *resultobj = 0;
6034 wxPoint *arg1 = (wxPoint *) 0 ;
6035 PyObject *result = 0 ;
6036 void *argp1 = 0 ;
6037 int res1 = 0 ;
6038 PyObject *swig_obj[1] ;
6039
6040 if (!args) SWIG_fail;
6041 swig_obj[0] = args;
6042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6043 if (!SWIG_IsOK(res1)) {
6044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6045 }
6046 arg1 = reinterpret_cast< wxPoint * >(argp1);
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (PyObject *)wxPoint_Get(arg1);
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 resultobj = result;
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6061 PyObject *obj;
6062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6063 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6064 return SWIG_Py_Void();
6065 }
6066
6067 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6068 return SWIG_Python_InitShadowInstance(args);
6069 }
6070
6071 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 int arg1 = (int) 0 ;
6074 int arg2 = (int) 0 ;
6075 int arg3 = (int) 0 ;
6076 int arg4 = (int) 0 ;
6077 wxRect *result = 0 ;
6078 int val1 ;
6079 int ecode1 = 0 ;
6080 int val2 ;
6081 int ecode2 = 0 ;
6082 int val3 ;
6083 int ecode3 = 0 ;
6084 int val4 ;
6085 int ecode4 = 0 ;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 PyObject * obj3 = 0 ;
6090 char * kwnames[] = {
6091 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6092 };
6093
6094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6095 if (obj0) {
6096 ecode1 = SWIG_AsVal_int(obj0, &val1);
6097 if (!SWIG_IsOK(ecode1)) {
6098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6099 }
6100 arg1 = static_cast< int >(val1);
6101 }
6102 if (obj1) {
6103 ecode2 = SWIG_AsVal_int(obj1, &val2);
6104 if (!SWIG_IsOK(ecode2)) {
6105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6106 }
6107 arg2 = static_cast< int >(val2);
6108 }
6109 if (obj2) {
6110 ecode3 = SWIG_AsVal_int(obj2, &val3);
6111 if (!SWIG_IsOK(ecode3)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6113 }
6114 arg3 = static_cast< int >(val3);
6115 }
6116 if (obj3) {
6117 ecode4 = SWIG_AsVal_int(obj3, &val4);
6118 if (!SWIG_IsOK(ecode4)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6120 }
6121 arg4 = static_cast< int >(val4);
6122 }
6123 {
6124 PyThreadState* __tstate = wxPyBeginAllowThreads();
6125 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj = 0;
6138 wxPoint *arg1 = 0 ;
6139 wxPoint *arg2 = 0 ;
6140 wxRect *result = 0 ;
6141 wxPoint temp1 ;
6142 wxPoint temp2 ;
6143 PyObject * obj0 = 0 ;
6144 PyObject * obj1 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "topLeft",(char *) "bottomRight", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6150 {
6151 arg1 = &temp1;
6152 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6153 }
6154 {
6155 arg2 = &temp2;
6156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj = 0;
6173 wxPoint *arg1 = 0 ;
6174 wxSize *arg2 = 0 ;
6175 wxRect *result = 0 ;
6176 wxPoint temp1 ;
6177 wxSize temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 char * kwnames[] = {
6181 (char *) "pos",(char *) "size", NULL
6182 };
6183
6184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6185 {
6186 arg1 = &temp1;
6187 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6188 }
6189 {
6190 arg2 = &temp2;
6191 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6192 }
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxSize *arg1 = 0 ;
6209 wxRect *result = 0 ;
6210 wxSize temp1 ;
6211 PyObject * obj0 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "size", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6217 {
6218 arg1 = &temp1;
6219 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6220 }
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6224 wxPyEndAllowThreads(__tstate);
6225 if (PyErr_Occurred()) SWIG_fail;
6226 }
6227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6235 PyObject *resultobj = 0;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 void *argp1 = 0 ;
6238 int res1 = 0 ;
6239 PyObject *swig_obj[1] ;
6240
6241 if (!args) SWIG_fail;
6242 swig_obj[0] = args;
6243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6244 if (!SWIG_IsOK(res1)) {
6245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6246 }
6247 arg1 = reinterpret_cast< wxRect * >(argp1);
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 delete arg1;
6251
6252 wxPyEndAllowThreads(__tstate);
6253 if (PyErr_Occurred()) SWIG_fail;
6254 }
6255 resultobj = SWIG_Py_Void();
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6263 PyObject *resultobj = 0;
6264 wxRect *arg1 = (wxRect *) 0 ;
6265 int result;
6266 void *argp1 = 0 ;
6267 int res1 = 0 ;
6268 PyObject *swig_obj[1] ;
6269
6270 if (!args) SWIG_fail;
6271 swig_obj[0] = args;
6272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6273 if (!SWIG_IsOK(res1)) {
6274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6275 }
6276 arg1 = reinterpret_cast< wxRect * >(argp1);
6277 {
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 result = (int)((wxRect const *)arg1)->GetX();
6280 wxPyEndAllowThreads(__tstate);
6281 if (PyErr_Occurred()) SWIG_fail;
6282 }
6283 resultobj = SWIG_From_int(static_cast< int >(result));
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj = 0;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int arg2 ;
6294 void *argp1 = 0 ;
6295 int res1 = 0 ;
6296 int val2 ;
6297 int ecode2 = 0 ;
6298 PyObject * obj0 = 0 ;
6299 PyObject * obj1 = 0 ;
6300 char * kwnames[] = {
6301 (char *) "self",(char *) "x", NULL
6302 };
6303
6304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6306 if (!SWIG_IsOK(res1)) {
6307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6308 }
6309 arg1 = reinterpret_cast< wxRect * >(argp1);
6310 ecode2 = SWIG_AsVal_int(obj1, &val2);
6311 if (!SWIG_IsOK(ecode2)) {
6312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6313 }
6314 arg2 = static_cast< int >(val2);
6315 {
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 (arg1)->SetX(arg2);
6318 wxPyEndAllowThreads(__tstate);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 resultobj = SWIG_Py_Void();
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6329 PyObject *resultobj = 0;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 int result;
6332 void *argp1 = 0 ;
6333 int res1 = 0 ;
6334 PyObject *swig_obj[1] ;
6335
6336 if (!args) SWIG_fail;
6337 swig_obj[0] = args;
6338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6339 if (!SWIG_IsOK(res1)) {
6340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6341 }
6342 arg1 = reinterpret_cast< wxRect * >(argp1);
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 result = (int)(arg1)->GetY();
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_From_int(static_cast< int >(result));
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6357 PyObject *resultobj = 0;
6358 wxRect *arg1 = (wxRect *) 0 ;
6359 int arg2 ;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 int val2 ;
6363 int ecode2 = 0 ;
6364 PyObject * obj0 = 0 ;
6365 PyObject * obj1 = 0 ;
6366 char * kwnames[] = {
6367 (char *) "self",(char *) "y", NULL
6368 };
6369
6370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 ecode2 = SWIG_AsVal_int(obj1, &val2);
6377 if (!SWIG_IsOK(ecode2)) {
6378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6379 }
6380 arg2 = static_cast< int >(val2);
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 (arg1)->SetY(arg2);
6384 wxPyEndAllowThreads(__tstate);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 resultobj = SWIG_Py_Void();
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395 PyObject *resultobj = 0;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 int result;
6398 void *argp1 = 0 ;
6399 int res1 = 0 ;
6400 PyObject *swig_obj[1] ;
6401
6402 if (!args) SWIG_fail;
6403 swig_obj[0] = args;
6404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6405 if (!SWIG_IsOK(res1)) {
6406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6407 }
6408 arg1 = reinterpret_cast< wxRect * >(argp1);
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (int)((wxRect const *)arg1)->GetWidth();
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 resultobj = SWIG_From_int(static_cast< int >(result));
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj = 0;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 int arg2 ;
6426 void *argp1 = 0 ;
6427 int res1 = 0 ;
6428 int val2 ;
6429 int ecode2 = 0 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char * kwnames[] = {
6433 (char *) "self",(char *) "w", NULL
6434 };
6435
6436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6438 if (!SWIG_IsOK(res1)) {
6439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6440 }
6441 arg1 = reinterpret_cast< wxRect * >(argp1);
6442 ecode2 = SWIG_AsVal_int(obj1, &val2);
6443 if (!SWIG_IsOK(ecode2)) {
6444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6445 }
6446 arg2 = static_cast< int >(val2);
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 (arg1)->SetWidth(arg2);
6450 wxPyEndAllowThreads(__tstate);
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 resultobj = SWIG_Py_Void();
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6461 PyObject *resultobj = 0;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int result;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 PyObject *swig_obj[1] ;
6467
6468 if (!args) SWIG_fail;
6469 swig_obj[0] = args;
6470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6471 if (!SWIG_IsOK(res1)) {
6472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6473 }
6474 arg1 = reinterpret_cast< wxRect * >(argp1);
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 result = (int)((wxRect const *)arg1)->GetHeight();
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_From_int(static_cast< int >(result));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj = 0;
6490 wxRect *arg1 = (wxRect *) 0 ;
6491 int arg2 ;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 int val2 ;
6495 int ecode2 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "h", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 ecode2 = SWIG_AsVal_int(obj1, &val2);
6509 if (!SWIG_IsOK(ecode2)) {
6510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6511 }
6512 arg2 = static_cast< int >(val2);
6513 {
6514 PyThreadState* __tstate = wxPyBeginAllowThreads();
6515 (arg1)->SetHeight(arg2);
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 resultobj = SWIG_Py_Void();
6520 return resultobj;
6521 fail:
6522 return NULL;
6523 }
6524
6525
6526 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6527 PyObject *resultobj = 0;
6528 wxRect *arg1 = (wxRect *) 0 ;
6529 wxPoint result;
6530 void *argp1 = 0 ;
6531 int res1 = 0 ;
6532 PyObject *swig_obj[1] ;
6533
6534 if (!args) SWIG_fail;
6535 swig_obj[0] = args;
6536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6539 }
6540 arg1 = reinterpret_cast< wxRect * >(argp1);
6541 {
6542 PyThreadState* __tstate = wxPyBeginAllowThreads();
6543 result = ((wxRect const *)arg1)->GetPosition();
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj = 0;
6556 wxRect *arg1 = (wxRect *) 0 ;
6557 wxPoint *arg2 = 0 ;
6558 void *argp1 = 0 ;
6559 int res1 = 0 ;
6560 wxPoint temp2 ;
6561 PyObject * obj0 = 0 ;
6562 PyObject * obj1 = 0 ;
6563 char * kwnames[] = {
6564 (char *) "self",(char *) "p", NULL
6565 };
6566
6567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6569 if (!SWIG_IsOK(res1)) {
6570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6571 }
6572 arg1 = reinterpret_cast< wxRect * >(argp1);
6573 {
6574 arg2 = &temp2;
6575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6576 }
6577 {
6578 PyThreadState* __tstate = wxPyBeginAllowThreads();
6579 (arg1)->SetPosition((wxPoint const &)*arg2);
6580 wxPyEndAllowThreads(__tstate);
6581 if (PyErr_Occurred()) SWIG_fail;
6582 }
6583 resultobj = SWIG_Py_Void();
6584 return resultobj;
6585 fail:
6586 return NULL;
6587 }
6588
6589
6590 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6591 PyObject *resultobj = 0;
6592 wxRect *arg1 = (wxRect *) 0 ;
6593 wxSize result;
6594 void *argp1 = 0 ;
6595 int res1 = 0 ;
6596 PyObject *swig_obj[1] ;
6597
6598 if (!args) SWIG_fail;
6599 swig_obj[0] = args;
6600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6601 if (!SWIG_IsOK(res1)) {
6602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6603 }
6604 arg1 = reinterpret_cast< wxRect * >(argp1);
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = ((wxRect const *)arg1)->GetSize();
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6612 return resultobj;
6613 fail:
6614 return NULL;
6615 }
6616
6617
6618 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6619 PyObject *resultobj = 0;
6620 wxRect *arg1 = (wxRect *) 0 ;
6621 wxSize *arg2 = 0 ;
6622 void *argp1 = 0 ;
6623 int res1 = 0 ;
6624 wxSize temp2 ;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 char * kwnames[] = {
6628 (char *) "self",(char *) "s", NULL
6629 };
6630
6631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 arg2 = &temp2;
6639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6640 }
6641 {
6642 PyThreadState* __tstate = wxPyBeginAllowThreads();
6643 (arg1)->SetSize((wxSize const &)*arg2);
6644 wxPyEndAllowThreads(__tstate);
6645 if (PyErr_Occurred()) SWIG_fail;
6646 }
6647 resultobj = SWIG_Py_Void();
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6655 PyObject *resultobj = 0;
6656 wxRect *arg1 = (wxRect *) 0 ;
6657 bool result;
6658 void *argp1 = 0 ;
6659 int res1 = 0 ;
6660 PyObject *swig_obj[1] ;
6661
6662 if (!args) SWIG_fail;
6663 swig_obj[0] = args;
6664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 result = (bool)((wxRect const *)arg1)->IsEmpty();
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 {
6676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6677 }
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6685 PyObject *resultobj = 0;
6686 wxRect *arg1 = (wxRect *) 0 ;
6687 wxPoint result;
6688 void *argp1 = 0 ;
6689 int res1 = 0 ;
6690 PyObject *swig_obj[1] ;
6691
6692 if (!args) SWIG_fail;
6693 swig_obj[0] = args;
6694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6695 if (!SWIG_IsOK(res1)) {
6696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6697 }
6698 arg1 = reinterpret_cast< wxRect * >(argp1);
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 result = ((wxRect const *)arg1)->GetTopLeft();
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj = 0;
6714 wxRect *arg1 = (wxRect *) 0 ;
6715 wxPoint *arg2 = 0 ;
6716 void *argp1 = 0 ;
6717 int res1 = 0 ;
6718 wxPoint temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char * kwnames[] = {
6722 (char *) "self",(char *) "p", NULL
6723 };
6724
6725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6727 if (!SWIG_IsOK(res1)) {
6728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6729 }
6730 arg1 = reinterpret_cast< wxRect * >(argp1);
6731 {
6732 arg2 = &temp2;
6733 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_Py_Void();
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6749 PyObject *resultobj = 0;
6750 wxRect *arg1 = (wxRect *) 0 ;
6751 wxPoint result;
6752 void *argp1 = 0 ;
6753 int res1 = 0 ;
6754 PyObject *swig_obj[1] ;
6755
6756 if (!args) SWIG_fail;
6757 swig_obj[0] = args;
6758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6759 if (!SWIG_IsOK(res1)) {
6760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6761 }
6762 arg1 = reinterpret_cast< wxRect * >(argp1);
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = ((wxRect const *)arg1)->GetBottomRight();
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj = 0;
6778 wxRect *arg1 = (wxRect *) 0 ;
6779 wxPoint *arg2 = 0 ;
6780 void *argp1 = 0 ;
6781 int res1 = 0 ;
6782 wxPoint temp2 ;
6783 PyObject * obj0 = 0 ;
6784 PyObject * obj1 = 0 ;
6785 char * kwnames[] = {
6786 (char *) "self",(char *) "p", NULL
6787 };
6788
6789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 arg2 = &temp2;
6797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_Py_Void();
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 wxRect *arg1 = (wxRect *) 0 ;
6815 int result;
6816 void *argp1 = 0 ;
6817 int res1 = 0 ;
6818 PyObject *swig_obj[1] ;
6819
6820 if (!args) SWIG_fail;
6821 swig_obj[0] = args;
6822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (int)((wxRect const *)arg1)->GetLeft();
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_From_int(static_cast< int >(result));
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 int result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxRect * >(argp1);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 result = (int)((wxRect const *)arg1)->GetTop();
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_From_int(static_cast< int >(result));
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 int result;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 PyObject *swig_obj[1] ;
6875
6876 if (!args) SWIG_fail;
6877 swig_obj[0] = args;
6878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6879 if (!SWIG_IsOK(res1)) {
6880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6881 }
6882 arg1 = reinterpret_cast< wxRect * >(argp1);
6883 {
6884 PyThreadState* __tstate = wxPyBeginAllowThreads();
6885 result = (int)((wxRect const *)arg1)->GetBottom();
6886 wxPyEndAllowThreads(__tstate);
6887 if (PyErr_Occurred()) SWIG_fail;
6888 }
6889 resultobj = SWIG_From_int(static_cast< int >(result));
6890 return resultobj;
6891 fail:
6892 return NULL;
6893 }
6894
6895
6896 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6897 PyObject *resultobj = 0;
6898 wxRect *arg1 = (wxRect *) 0 ;
6899 int result;
6900 void *argp1 = 0 ;
6901 int res1 = 0 ;
6902 PyObject *swig_obj[1] ;
6903
6904 if (!args) SWIG_fail;
6905 swig_obj[0] = args;
6906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6907 if (!SWIG_IsOK(res1)) {
6908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6909 }
6910 arg1 = reinterpret_cast< wxRect * >(argp1);
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (int)((wxRect const *)arg1)->GetRight();
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 resultobj = SWIG_From_int(static_cast< int >(result));
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6925 PyObject *resultobj = 0;
6926 wxRect *arg1 = (wxRect *) 0 ;
6927 int arg2 ;
6928 void *argp1 = 0 ;
6929 int res1 = 0 ;
6930 int val2 ;
6931 int ecode2 = 0 ;
6932 PyObject * obj0 = 0 ;
6933 PyObject * obj1 = 0 ;
6934 char * kwnames[] = {
6935 (char *) "self",(char *) "left", NULL
6936 };
6937
6938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6940 if (!SWIG_IsOK(res1)) {
6941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6942 }
6943 arg1 = reinterpret_cast< wxRect * >(argp1);
6944 ecode2 = SWIG_AsVal_int(obj1, &val2);
6945 if (!SWIG_IsOK(ecode2)) {
6946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6947 }
6948 arg2 = static_cast< int >(val2);
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 (arg1)->SetLeft(arg2);
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 resultobj = SWIG_Py_Void();
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6963 PyObject *resultobj = 0;
6964 wxRect *arg1 = (wxRect *) 0 ;
6965 int arg2 ;
6966 void *argp1 = 0 ;
6967 int res1 = 0 ;
6968 int val2 ;
6969 int ecode2 = 0 ;
6970 PyObject * obj0 = 0 ;
6971 PyObject * obj1 = 0 ;
6972 char * kwnames[] = {
6973 (char *) "self",(char *) "right", NULL
6974 };
6975
6976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6978 if (!SWIG_IsOK(res1)) {
6979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6980 }
6981 arg1 = reinterpret_cast< wxRect * >(argp1);
6982 ecode2 = SWIG_AsVal_int(obj1, &val2);
6983 if (!SWIG_IsOK(ecode2)) {
6984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6985 }
6986 arg2 = static_cast< int >(val2);
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 (arg1)->SetRight(arg2);
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_Py_Void();
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxRect *arg1 = (wxRect *) 0 ;
7003 int arg2 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 int val2 ;
7007 int ecode2 = 0 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 char * kwnames[] = {
7011 (char *) "self",(char *) "top", NULL
7012 };
7013
7014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7016 if (!SWIG_IsOK(res1)) {
7017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7018 }
7019 arg1 = reinterpret_cast< wxRect * >(argp1);
7020 ecode2 = SWIG_AsVal_int(obj1, &val2);
7021 if (!SWIG_IsOK(ecode2)) {
7022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7023 }
7024 arg2 = static_cast< int >(val2);
7025 {
7026 PyThreadState* __tstate = wxPyBeginAllowThreads();
7027 (arg1)->SetTop(arg2);
7028 wxPyEndAllowThreads(__tstate);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_Py_Void();
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7039 PyObject *resultobj = 0;
7040 wxRect *arg1 = (wxRect *) 0 ;
7041 int arg2 ;
7042 void *argp1 = 0 ;
7043 int res1 = 0 ;
7044 int val2 ;
7045 int ecode2 = 0 ;
7046 PyObject * obj0 = 0 ;
7047 PyObject * obj1 = 0 ;
7048 char * kwnames[] = {
7049 (char *) "self",(char *) "bottom", NULL
7050 };
7051
7052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7054 if (!SWIG_IsOK(res1)) {
7055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7056 }
7057 arg1 = reinterpret_cast< wxRect * >(argp1);
7058 ecode2 = SWIG_AsVal_int(obj1, &val2);
7059 if (!SWIG_IsOK(ecode2)) {
7060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7061 }
7062 arg2 = static_cast< int >(val2);
7063 {
7064 PyThreadState* __tstate = wxPyBeginAllowThreads();
7065 (arg1)->SetBottom(arg2);
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_Py_Void();
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int arg2 ;
7080 int arg3 ;
7081 wxRect *result = 0 ;
7082 void *argp1 = 0 ;
7083 int res1 = 0 ;
7084 int val2 ;
7085 int ecode2 = 0 ;
7086 int val3 ;
7087 int ecode3 = 0 ;
7088 PyObject * obj0 = 0 ;
7089 PyObject * obj1 = 0 ;
7090 PyObject * obj2 = 0 ;
7091 char * kwnames[] = {
7092 (char *) "self",(char *) "dx",(char *) "dy", NULL
7093 };
7094
7095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7097 if (!SWIG_IsOK(res1)) {
7098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7099 }
7100 arg1 = reinterpret_cast< wxRect * >(argp1);
7101 ecode2 = SWIG_AsVal_int(obj1, &val2);
7102 if (!SWIG_IsOK(ecode2)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7104 }
7105 arg2 = static_cast< int >(val2);
7106 ecode3 = SWIG_AsVal_int(obj2, &val3);
7107 if (!SWIG_IsOK(ecode3)) {
7108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7109 }
7110 arg3 = static_cast< int >(val3);
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 {
7114 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7115 result = (wxRect *) &_result_ref;
7116 }
7117 wxPyEndAllowThreads(__tstate);
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj = 0;
7129 wxRect *arg1 = (wxRect *) 0 ;
7130 int arg2 ;
7131 int arg3 ;
7132 wxRect *result = 0 ;
7133 void *argp1 = 0 ;
7134 int res1 = 0 ;
7135 int val2 ;
7136 int ecode2 = 0 ;
7137 int val3 ;
7138 int ecode3 = 0 ;
7139 PyObject * obj0 = 0 ;
7140 PyObject * obj1 = 0 ;
7141 PyObject * obj2 = 0 ;
7142 char * kwnames[] = {
7143 (char *) "self",(char *) "dx",(char *) "dy", NULL
7144 };
7145
7146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7148 if (!SWIG_IsOK(res1)) {
7149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7150 }
7151 arg1 = reinterpret_cast< wxRect * >(argp1);
7152 ecode2 = SWIG_AsVal_int(obj1, &val2);
7153 if (!SWIG_IsOK(ecode2)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7155 }
7156 arg2 = static_cast< int >(val2);
7157 ecode3 = SWIG_AsVal_int(obj2, &val3);
7158 if (!SWIG_IsOK(ecode3)) {
7159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7160 }
7161 arg3 = static_cast< int >(val3);
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 {
7165 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7166 result = (wxRect *) &_result_ref;
7167 }
7168 wxPyEndAllowThreads(__tstate);
7169 if (PyErr_Occurred()) SWIG_fail;
7170 }
7171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj = 0;
7180 wxRect *arg1 = (wxRect *) 0 ;
7181 int arg2 ;
7182 int arg3 ;
7183 void *argp1 = 0 ;
7184 int res1 = 0 ;
7185 int val2 ;
7186 int ecode2 = 0 ;
7187 int val3 ;
7188 int ecode3 = 0 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 PyObject * obj2 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "dx",(char *) "dy", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 ecode2 = SWIG_AsVal_int(obj1, &val2);
7203 if (!SWIG_IsOK(ecode2)) {
7204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7205 }
7206 arg2 = static_cast< int >(val2);
7207 ecode3 = SWIG_AsVal_int(obj2, &val3);
7208 if (!SWIG_IsOK(ecode3)) {
7209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7210 }
7211 arg3 = static_cast< int >(val3);
7212 {
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 (arg1)->Offset(arg2,arg3);
7215 wxPyEndAllowThreads(__tstate);
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 resultobj = SWIG_Py_Void();
7219 return resultobj;
7220 fail:
7221 return NULL;
7222 }
7223
7224
7225 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7226 PyObject *resultobj = 0;
7227 wxRect *arg1 = (wxRect *) 0 ;
7228 wxPoint *arg2 = 0 ;
7229 void *argp1 = 0 ;
7230 int res1 = 0 ;
7231 wxPoint temp2 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "pt", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 {
7245 arg2 = &temp2;
7246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7247 }
7248 {
7249 PyThreadState* __tstate = wxPyBeginAllowThreads();
7250 (arg1)->Offset((wxPoint const &)*arg2);
7251 wxPyEndAllowThreads(__tstate);
7252 if (PyErr_Occurred()) SWIG_fail;
7253 }
7254 resultobj = SWIG_Py_Void();
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxRect *arg1 = (wxRect *) 0 ;
7264 wxRect *arg2 = 0 ;
7265 wxRect result;
7266 void *argp1 = 0 ;
7267 int res1 = 0 ;
7268 wxRect temp2 ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "rect", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7279 }
7280 arg1 = reinterpret_cast< wxRect * >(argp1);
7281 {
7282 arg2 = &temp2;
7283 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7284 }
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 result = (arg1)->Intersect((wxRect const &)*arg2);
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj = 0;
7300 wxRect *arg1 = (wxRect *) 0 ;
7301 wxRect *arg2 = 0 ;
7302 wxRect result;
7303 void *argp1 = 0 ;
7304 int res1 = 0 ;
7305 wxRect temp2 ;
7306 PyObject * obj0 = 0 ;
7307 PyObject * obj1 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "self",(char *) "rect", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7314 if (!SWIG_IsOK(res1)) {
7315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7316 }
7317 arg1 = reinterpret_cast< wxRect * >(argp1);
7318 {
7319 arg2 = &temp2;
7320 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7321 }
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 result = (arg1)->Union((wxRect const &)*arg2);
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxRect *arg1 = (wxRect *) 0 ;
7338 wxRect *arg2 = 0 ;
7339 wxRect result;
7340 void *argp1 = 0 ;
7341 int res1 = 0 ;
7342 wxRect temp2 ;
7343 PyObject * obj0 = 0 ;
7344 PyObject * obj1 = 0 ;
7345 char * kwnames[] = {
7346 (char *) "self",(char *) "rect", NULL
7347 };
7348
7349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7351 if (!SWIG_IsOK(res1)) {
7352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7353 }
7354 arg1 = reinterpret_cast< wxRect * >(argp1);
7355 {
7356 arg2 = &temp2;
7357 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7358 }
7359 {
7360 PyThreadState* __tstate = wxPyBeginAllowThreads();
7361 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj = 0;
7374 wxRect *arg1 = (wxRect *) 0 ;
7375 wxRect *arg2 = 0 ;
7376 wxRect *result = 0 ;
7377 void *argp1 = 0 ;
7378 int res1 = 0 ;
7379 wxRect temp2 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 char * kwnames[] = {
7383 (char *) "self",(char *) "rect", NULL
7384 };
7385
7386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7390 }
7391 arg1 = reinterpret_cast< wxRect * >(argp1);
7392 {
7393 arg2 = &temp2;
7394 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7395 }
7396 {
7397 PyThreadState* __tstate = wxPyBeginAllowThreads();
7398 {
7399 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7400 result = (wxRect *) &_result_ref;
7401 }
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj = 0;
7414 wxRect *arg1 = (wxRect *) 0 ;
7415 PyObject *arg2 = (PyObject *) 0 ;
7416 bool result;
7417 void *argp1 = 0 ;
7418 int res1 = 0 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 char * kwnames[] = {
7422 (char *) "self",(char *) "other", NULL
7423 };
7424
7425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7427 if (!SWIG_IsOK(res1)) {
7428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7429 }
7430 arg1 = reinterpret_cast< wxRect * >(argp1);
7431 arg2 = obj1;
7432 {
7433 result = (bool)wxRect___eq__(arg1,arg2);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7438 }
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj = 0;
7447 wxRect *arg1 = (wxRect *) 0 ;
7448 PyObject *arg2 = (PyObject *) 0 ;
7449 bool result;
7450 void *argp1 = 0 ;
7451 int res1 = 0 ;
7452 PyObject * obj0 = 0 ;
7453 PyObject * obj1 = 0 ;
7454 char * kwnames[] = {
7455 (char *) "self",(char *) "other", NULL
7456 };
7457
7458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7460 if (!SWIG_IsOK(res1)) {
7461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7462 }
7463 arg1 = reinterpret_cast< wxRect * >(argp1);
7464 arg2 = obj1;
7465 {
7466 result = (bool)wxRect___ne__(arg1,arg2);
7467 if (PyErr_Occurred()) SWIG_fail;
7468 }
7469 {
7470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7471 }
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj = 0;
7480 wxRect *arg1 = (wxRect *) 0 ;
7481 int arg2 ;
7482 int arg3 ;
7483 bool result;
7484 void *argp1 = 0 ;
7485 int res1 = 0 ;
7486 int val2 ;
7487 int ecode2 = 0 ;
7488 int val3 ;
7489 int ecode3 = 0 ;
7490 PyObject * obj0 = 0 ;
7491 PyObject * obj1 = 0 ;
7492 PyObject * obj2 = 0 ;
7493 char * kwnames[] = {
7494 (char *) "self",(char *) "x",(char *) "y", NULL
7495 };
7496
7497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7501 }
7502 arg1 = reinterpret_cast< wxRect * >(argp1);
7503 ecode2 = SWIG_AsVal_int(obj1, &val2);
7504 if (!SWIG_IsOK(ecode2)) {
7505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7506 }
7507 arg2 = static_cast< int >(val2);
7508 ecode3 = SWIG_AsVal_int(obj2, &val3);
7509 if (!SWIG_IsOK(ecode3)) {
7510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7511 }
7512 arg3 = static_cast< int >(val3);
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7516 wxPyEndAllowThreads(__tstate);
7517 if (PyErr_Occurred()) SWIG_fail;
7518 }
7519 {
7520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7521 }
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj = 0;
7530 wxRect *arg1 = (wxRect *) 0 ;
7531 wxPoint *arg2 = 0 ;
7532 bool result;
7533 void *argp1 = 0 ;
7534 int res1 = 0 ;
7535 wxPoint temp2 ;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char * kwnames[] = {
7539 (char *) "self",(char *) "pt", NULL
7540 };
7541
7542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7544 if (!SWIG_IsOK(res1)) {
7545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7546 }
7547 arg1 = reinterpret_cast< wxRect * >(argp1);
7548 {
7549 arg2 = &temp2;
7550 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7551 }
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7555 wxPyEndAllowThreads(__tstate);
7556 if (PyErr_Occurred()) SWIG_fail;
7557 }
7558 {
7559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7560 }
7561 return resultobj;
7562 fail:
7563 return NULL;
7564 }
7565
7566
7567 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7568 PyObject *resultobj = 0;
7569 wxRect *arg1 = (wxRect *) 0 ;
7570 wxRect *arg2 = 0 ;
7571 bool result;
7572 void *argp1 = 0 ;
7573 int res1 = 0 ;
7574 wxRect temp2 ;
7575 PyObject * obj0 = 0 ;
7576 PyObject * obj1 = 0 ;
7577 char * kwnames[] = {
7578 (char *) "self",(char *) "rect", NULL
7579 };
7580
7581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7583 if (!SWIG_IsOK(res1)) {
7584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7585 }
7586 arg1 = reinterpret_cast< wxRect * >(argp1);
7587 {
7588 arg2 = &temp2;
7589 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7590 }
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj = 0;
7608 wxRect *arg1 = (wxRect *) 0 ;
7609 wxRect *arg2 = 0 ;
7610 bool result;
7611 void *argp1 = 0 ;
7612 int res1 = 0 ;
7613 wxRect temp2 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "rect", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7624 }
7625 arg1 = reinterpret_cast< wxRect * >(argp1);
7626 {
7627 arg2 = &temp2;
7628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7629 }
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 {
7637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7638 }
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj = 0;
7647 wxRect *arg1 = (wxRect *) 0 ;
7648 wxRect *arg2 = 0 ;
7649 int arg3 = (int) wxBOTH ;
7650 wxRect result;
7651 void *argp1 = 0 ;
7652 int res1 = 0 ;
7653 wxRect temp2 ;
7654 int val3 ;
7655 int ecode3 = 0 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 PyObject * obj2 = 0 ;
7659 char * kwnames[] = {
7660 (char *) "self",(char *) "r",(char *) "dir", NULL
7661 };
7662
7663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7665 if (!SWIG_IsOK(res1)) {
7666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7667 }
7668 arg1 = reinterpret_cast< wxRect * >(argp1);
7669 {
7670 arg2 = &temp2;
7671 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7672 }
7673 if (obj2) {
7674 ecode3 = SWIG_AsVal_int(obj2, &val3);
7675 if (!SWIG_IsOK(ecode3)) {
7676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7677 }
7678 arg3 = static_cast< int >(val3);
7679 }
7680 {
7681 PyThreadState* __tstate = wxPyBeginAllowThreads();
7682 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7694 PyObject *resultobj = 0;
7695 wxRect *arg1 = (wxRect *) 0 ;
7696 int arg2 ;
7697 void *argp1 = 0 ;
7698 int res1 = 0 ;
7699 int val2 ;
7700 int ecode2 = 0 ;
7701 PyObject *swig_obj[2] ;
7702
7703 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7705 if (!SWIG_IsOK(res1)) {
7706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7707 }
7708 arg1 = reinterpret_cast< wxRect * >(argp1);
7709 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7710 if (!SWIG_IsOK(ecode2)) {
7711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7712 }
7713 arg2 = static_cast< int >(val2);
7714 if (arg1) (arg1)->x = arg2;
7715
7716 resultobj = SWIG_Py_Void();
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 int result;
7727 void *argp1 = 0 ;
7728 int res1 = 0 ;
7729 PyObject *swig_obj[1] ;
7730
7731 if (!args) SWIG_fail;
7732 swig_obj[0] = args;
7733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 result = (int) ((arg1)->x);
7739 resultobj = SWIG_From_int(static_cast< int >(result));
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7747 PyObject *resultobj = 0;
7748 wxRect *arg1 = (wxRect *) 0 ;
7749 int arg2 ;
7750 void *argp1 = 0 ;
7751 int res1 = 0 ;
7752 int val2 ;
7753 int ecode2 = 0 ;
7754 PyObject *swig_obj[2] ;
7755
7756 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7760 }
7761 arg1 = reinterpret_cast< wxRect * >(argp1);
7762 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7765 }
7766 arg2 = static_cast< int >(val2);
7767 if (arg1) (arg1)->y = arg2;
7768
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7777 PyObject *resultobj = 0;
7778 wxRect *arg1 = (wxRect *) 0 ;
7779 int result;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 PyObject *swig_obj[1] ;
7783
7784 if (!args) SWIG_fail;
7785 swig_obj[0] = args;
7786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7787 if (!SWIG_IsOK(res1)) {
7788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7789 }
7790 arg1 = reinterpret_cast< wxRect * >(argp1);
7791 result = (int) ((arg1)->y);
7792 resultobj = SWIG_From_int(static_cast< int >(result));
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 int arg2 ;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 int val2 ;
7806 int ecode2 = 0 ;
7807 PyObject *swig_obj[2] ;
7808
7809 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7811 if (!SWIG_IsOK(res1)) {
7812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7813 }
7814 arg1 = reinterpret_cast< wxRect * >(argp1);
7815 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7816 if (!SWIG_IsOK(ecode2)) {
7817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7818 }
7819 arg2 = static_cast< int >(val2);
7820 if (arg1) (arg1)->width = arg2;
7821
7822 resultobj = SWIG_Py_Void();
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7830 PyObject *resultobj = 0;
7831 wxRect *arg1 = (wxRect *) 0 ;
7832 int result;
7833 void *argp1 = 0 ;
7834 int res1 = 0 ;
7835 PyObject *swig_obj[1] ;
7836
7837 if (!args) SWIG_fail;
7838 swig_obj[0] = args;
7839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7840 if (!SWIG_IsOK(res1)) {
7841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7842 }
7843 arg1 = reinterpret_cast< wxRect * >(argp1);
7844 result = (int) ((arg1)->width);
7845 resultobj = SWIG_From_int(static_cast< int >(result));
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7853 PyObject *resultobj = 0;
7854 wxRect *arg1 = (wxRect *) 0 ;
7855 int arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 int val2 ;
7859 int ecode2 = 0 ;
7860 PyObject *swig_obj[2] ;
7861
7862 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7864 if (!SWIG_IsOK(res1)) {
7865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7866 }
7867 arg1 = reinterpret_cast< wxRect * >(argp1);
7868 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7869 if (!SWIG_IsOK(ecode2)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7871 }
7872 arg2 = static_cast< int >(val2);
7873 if (arg1) (arg1)->height = arg2;
7874
7875 resultobj = SWIG_Py_Void();
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7883 PyObject *resultobj = 0;
7884 wxRect *arg1 = (wxRect *) 0 ;
7885 int result;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 PyObject *swig_obj[1] ;
7889
7890 if (!args) SWIG_fail;
7891 swig_obj[0] = args;
7892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7893 if (!SWIG_IsOK(res1)) {
7894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7895 }
7896 arg1 = reinterpret_cast< wxRect * >(argp1);
7897 result = (int) ((arg1)->height);
7898 resultobj = SWIG_From_int(static_cast< int >(result));
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj = 0;
7907 wxRect *arg1 = (wxRect *) 0 ;
7908 int arg2 = (int) 0 ;
7909 int arg3 = (int) 0 ;
7910 int arg4 = (int) 0 ;
7911 int arg5 = (int) 0 ;
7912 void *argp1 = 0 ;
7913 int res1 = 0 ;
7914 int val2 ;
7915 int ecode2 = 0 ;
7916 int val3 ;
7917 int ecode3 = 0 ;
7918 int val4 ;
7919 int ecode4 = 0 ;
7920 int val5 ;
7921 int ecode5 = 0 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 PyObject * obj2 = 0 ;
7925 PyObject * obj3 = 0 ;
7926 PyObject * obj4 = 0 ;
7927 char * kwnames[] = {
7928 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7929 };
7930
7931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res1)) {
7934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7935 }
7936 arg1 = reinterpret_cast< wxRect * >(argp1);
7937 if (obj1) {
7938 ecode2 = SWIG_AsVal_int(obj1, &val2);
7939 if (!SWIG_IsOK(ecode2)) {
7940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7941 }
7942 arg2 = static_cast< int >(val2);
7943 }
7944 if (obj2) {
7945 ecode3 = SWIG_AsVal_int(obj2, &val3);
7946 if (!SWIG_IsOK(ecode3)) {
7947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7948 }
7949 arg3 = static_cast< int >(val3);
7950 }
7951 if (obj3) {
7952 ecode4 = SWIG_AsVal_int(obj3, &val4);
7953 if (!SWIG_IsOK(ecode4)) {
7954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7955 }
7956 arg4 = static_cast< int >(val4);
7957 }
7958 if (obj4) {
7959 ecode5 = SWIG_AsVal_int(obj4, &val5);
7960 if (!SWIG_IsOK(ecode5)) {
7961 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7962 }
7963 arg5 = static_cast< int >(val5);
7964 }
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979 PyObject *resultobj = 0;
7980 wxRect *arg1 = (wxRect *) 0 ;
7981 PyObject *result = 0 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 PyObject *swig_obj[1] ;
7985
7986 if (!args) SWIG_fail;
7987 swig_obj[0] = args;
7988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7989 if (!SWIG_IsOK(res1)) {
7990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7991 }
7992 arg1 = reinterpret_cast< wxRect * >(argp1);
7993 {
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 result = (PyObject *)wxRect_Get(arg1);
7996 wxPyEndAllowThreads(__tstate);
7997 if (PyErr_Occurred()) SWIG_fail;
7998 }
7999 resultobj = result;
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *obj;
8008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8009 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8010 return SWIG_Py_Void();
8011 }
8012
8013 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8014 return SWIG_Python_InitShadowInstance(args);
8015 }
8016
8017 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj = 0;
8019 wxRect *arg1 = (wxRect *) 0 ;
8020 wxRect *arg2 = (wxRect *) 0 ;
8021 PyObject *result = 0 ;
8022 void *argp1 = 0 ;
8023 int res1 = 0 ;
8024 void *argp2 = 0 ;
8025 int res2 = 0 ;
8026 PyObject * obj0 = 0 ;
8027 PyObject * obj1 = 0 ;
8028 char * kwnames[] = {
8029 (char *) "r1",(char *) "r2", NULL
8030 };
8031
8032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8034 if (!SWIG_IsOK(res1)) {
8035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8036 }
8037 arg1 = reinterpret_cast< wxRect * >(argp1);
8038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8039 if (!SWIG_IsOK(res2)) {
8040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8041 }
8042 arg2 = reinterpret_cast< wxRect * >(argp2);
8043 {
8044 if (!wxPyCheckForApp()) SWIG_fail;
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 result = (PyObject *)wxIntersectRect(arg1,arg2);
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = result;
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj = 0;
8059 double arg1 = (double) 0.0 ;
8060 double arg2 = (double) 0.0 ;
8061 wxPoint2D *result = 0 ;
8062 double val1 ;
8063 int ecode1 = 0 ;
8064 double val2 ;
8065 int ecode2 = 0 ;
8066 PyObject * obj0 = 0 ;
8067 PyObject * obj1 = 0 ;
8068 char * kwnames[] = {
8069 (char *) "x",(char *) "y", NULL
8070 };
8071
8072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8073 if (obj0) {
8074 ecode1 = SWIG_AsVal_double(obj0, &val1);
8075 if (!SWIG_IsOK(ecode1)) {
8076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8077 }
8078 arg1 = static_cast< double >(val1);
8079 }
8080 if (obj1) {
8081 ecode2 = SWIG_AsVal_double(obj1, &val2);
8082 if (!SWIG_IsOK(ecode2)) {
8083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8084 }
8085 arg2 = static_cast< double >(val2);
8086 }
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj = 0;
8102 wxPoint2D *arg1 = 0 ;
8103 wxPoint2D *result = 0 ;
8104 wxPoint2D temp1 ;
8105 PyObject * obj0 = 0 ;
8106 char * kwnames[] = {
8107 (char *) "pt", NULL
8108 };
8109
8110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8111 {
8112 arg1 = &temp1;
8113 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8114 }
8115 {
8116 PyThreadState* __tstate = wxPyBeginAllowThreads();
8117 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj = 0;
8130 wxPoint *arg1 = 0 ;
8131 wxPoint2D *result = 0 ;
8132 wxPoint temp1 ;
8133 PyObject * obj0 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "pt", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8139 {
8140 arg1 = &temp1;
8141 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8142 }
8143 {
8144 PyThreadState* __tstate = wxPyBeginAllowThreads();
8145 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *resultobj = 0;
8158 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8159 int *arg2 = (int *) 0 ;
8160 int *arg3 = (int *) 0 ;
8161 void *argp1 = 0 ;
8162 int res1 = 0 ;
8163 int temp2 ;
8164 int res2 = SWIG_TMPOBJ ;
8165 int temp3 ;
8166 int res3 = SWIG_TMPOBJ ;
8167 PyObject *swig_obj[1] ;
8168
8169 arg2 = &temp2;
8170 arg3 = &temp3;
8171 if (!args) SWIG_fail;
8172 swig_obj[0] = args;
8173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8174 if (!SWIG_IsOK(res1)) {
8175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8176 }
8177 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8178 {
8179 PyThreadState* __tstate = wxPyBeginAllowThreads();
8180 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8181 wxPyEndAllowThreads(__tstate);
8182 if (PyErr_Occurred()) SWIG_fail;
8183 }
8184 resultobj = SWIG_Py_Void();
8185 if (SWIG_IsTmpObj(res2)) {
8186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8187 } else {
8188 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8190 }
8191 if (SWIG_IsTmpObj(res3)) {
8192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8193 } else {
8194 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8196 }
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8204 PyObject *resultobj = 0;
8205 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8206 int *arg2 = (int *) 0 ;
8207 int *arg3 = (int *) 0 ;
8208 void *argp1 = 0 ;
8209 int res1 = 0 ;
8210 int temp2 ;
8211 int res2 = SWIG_TMPOBJ ;
8212 int temp3 ;
8213 int res3 = SWIG_TMPOBJ ;
8214 PyObject *swig_obj[1] ;
8215
8216 arg2 = &temp2;
8217 arg3 = &temp3;
8218 if (!args) SWIG_fail;
8219 swig_obj[0] = args;
8220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8223 }
8224 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8228 wxPyEndAllowThreads(__tstate);
8229 if (PyErr_Occurred()) SWIG_fail;
8230 }
8231 resultobj = SWIG_Py_Void();
8232 if (SWIG_IsTmpObj(res2)) {
8233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8234 } else {
8235 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8237 }
8238 if (SWIG_IsTmpObj(res3)) {
8239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8240 } else {
8241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8243 }
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 PyObject *resultobj = 0;
8252 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8253 double result;
8254 void *argp1 = 0 ;
8255 int res1 = 0 ;
8256 PyObject *swig_obj[1] ;
8257
8258 if (!args) SWIG_fail;
8259 swig_obj[0] = args;
8260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8261 if (!SWIG_IsOK(res1)) {
8262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8263 }
8264 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_From_double(static_cast< double >(result));
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8279 PyObject *resultobj = 0;
8280 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8281 double result;
8282 void *argp1 = 0 ;
8283 int res1 = 0 ;
8284 PyObject *swig_obj[1] ;
8285
8286 if (!args) SWIG_fail;
8287 swig_obj[0] = args;
8288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8289 if (!SWIG_IsOK(res1)) {
8290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8291 }
8292 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8293 {
8294 PyThreadState* __tstate = wxPyBeginAllowThreads();
8295 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 resultobj = SWIG_From_double(static_cast< double >(result));
8300 return resultobj;
8301 fail:
8302 return NULL;
8303 }
8304
8305
8306 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8307 PyObject *resultobj = 0;
8308 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8309 double arg2 ;
8310 void *argp1 = 0 ;
8311 int res1 = 0 ;
8312 double val2 ;
8313 int ecode2 = 0 ;
8314 PyObject * obj0 = 0 ;
8315 PyObject * obj1 = 0 ;
8316 char * kwnames[] = {
8317 (char *) "self",(char *) "length", NULL
8318 };
8319
8320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8322 if (!SWIG_IsOK(res1)) {
8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8324 }
8325 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8326 ecode2 = SWIG_AsVal_double(obj1, &val2);
8327 if (!SWIG_IsOK(ecode2)) {
8328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8329 }
8330 arg2 = static_cast< double >(val2);
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 (arg1)->SetVectorLength(arg2);
8334 wxPyEndAllowThreads(__tstate);
8335 if (PyErr_Occurred()) SWIG_fail;
8336 }
8337 resultobj = SWIG_Py_Void();
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8347 double arg2 ;
8348 void *argp1 = 0 ;
8349 int res1 = 0 ;
8350 double val2 ;
8351 int ecode2 = 0 ;
8352 PyObject * obj0 = 0 ;
8353 PyObject * obj1 = 0 ;
8354 char * kwnames[] = {
8355 (char *) "self",(char *) "degrees", NULL
8356 };
8357
8358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8360 if (!SWIG_IsOK(res1)) {
8361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8362 }
8363 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8364 ecode2 = SWIG_AsVal_double(obj1, &val2);
8365 if (!SWIG_IsOK(ecode2)) {
8366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8367 }
8368 arg2 = static_cast< double >(val2);
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 (arg1)->SetVectorAngle(arg2);
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 resultobj = SWIG_Py_Void();
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj = 0;
8384 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8385 wxPoint2D *arg2 = 0 ;
8386 double result;
8387 void *argp1 = 0 ;
8388 int res1 = 0 ;
8389 wxPoint2D temp2 ;
8390 PyObject * obj0 = 0 ;
8391 PyObject * obj1 = 0 ;
8392 char * kwnames[] = {
8393 (char *) "self",(char *) "pt", NULL
8394 };
8395
8396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8398 if (!SWIG_IsOK(res1)) {
8399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8400 }
8401 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8402 {
8403 arg2 = &temp2;
8404 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8405 }
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_From_double(static_cast< double >(result));
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj = 0;
8421 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8422 wxPoint2D *arg2 = 0 ;
8423 double result;
8424 void *argp1 = 0 ;
8425 int res1 = 0 ;
8426 wxPoint2D temp2 ;
8427 PyObject * obj0 = 0 ;
8428 PyObject * obj1 = 0 ;
8429 char * kwnames[] = {
8430 (char *) "self",(char *) "pt", NULL
8431 };
8432
8433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8435 if (!SWIG_IsOK(res1)) {
8436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8437 }
8438 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8439 {
8440 arg2 = &temp2;
8441 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8442 }
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_From_double(static_cast< double >(result));
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 double result;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "vec", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 resultobj = SWIG_From_double(static_cast< double >(result));
8487 return resultobj;
8488 fail:
8489 return NULL;
8490 }
8491
8492
8493 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8494 PyObject *resultobj = 0;
8495 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8496 wxPoint2D *arg2 = 0 ;
8497 double result;
8498 void *argp1 = 0 ;
8499 int res1 = 0 ;
8500 wxPoint2D temp2 ;
8501 PyObject * obj0 = 0 ;
8502 PyObject * obj1 = 0 ;
8503 char * kwnames[] = {
8504 (char *) "self",(char *) "vec", NULL
8505 };
8506
8507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8509 if (!SWIG_IsOK(res1)) {
8510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8511 }
8512 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8513 {
8514 arg2 = &temp2;
8515 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 resultobj = SWIG_From_double(static_cast< double >(result));
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531 PyObject *resultobj = 0;
8532 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8533 wxPoint2D result;
8534 void *argp1 = 0 ;
8535 int res1 = 0 ;
8536 PyObject *swig_obj[1] ;
8537
8538 if (!args) SWIG_fail;
8539 swig_obj[0] = args;
8540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8543 }
8544 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (arg1)->operator -();
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj = 0;
8560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8561 wxPoint2D *arg2 = 0 ;
8562 wxPoint2D *result = 0 ;
8563 void *argp1 = 0 ;
8564 int res1 = 0 ;
8565 wxPoint2D temp2 ;
8566 PyObject * obj0 = 0 ;
8567 PyObject * obj1 = 0 ;
8568 char * kwnames[] = {
8569 (char *) "self",(char *) "pt", NULL
8570 };
8571
8572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8574 if (!SWIG_IsOK(res1)) {
8575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8576 }
8577 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8578 {
8579 arg2 = &temp2;
8580 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8581 }
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 {
8585 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8586 result = (wxPoint2D *) &_result_ref;
8587 }
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj = 0;
8600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8601 wxPoint2D *arg2 = 0 ;
8602 wxPoint2D *result = 0 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 wxPoint2D temp2 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "pt", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8616 }
8617 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8618 {
8619 arg2 = &temp2;
8620 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8621 }
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 {
8625 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8626 result = (wxPoint2D *) &_result_ref;
8627 }
8628 wxPyEndAllowThreads(__tstate);
8629 if (PyErr_Occurred()) SWIG_fail;
8630 }
8631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8632 return resultobj;
8633 fail:
8634 return NULL;
8635 }
8636
8637
8638 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8639 PyObject *resultobj = 0;
8640 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8641 wxPoint2D *arg2 = 0 ;
8642 wxPoint2D *result = 0 ;
8643 void *argp1 = 0 ;
8644 int res1 = 0 ;
8645 wxPoint2D temp2 ;
8646 PyObject * obj0 = 0 ;
8647 PyObject * obj1 = 0 ;
8648 char * kwnames[] = {
8649 (char *) "self",(char *) "pt", NULL
8650 };
8651
8652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8654 if (!SWIG_IsOK(res1)) {
8655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8656 }
8657 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8658 {
8659 arg2 = &temp2;
8660 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8661 }
8662 {
8663 PyThreadState* __tstate = wxPyBeginAllowThreads();
8664 {
8665 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8666 result = (wxPoint2D *) &_result_ref;
8667 }
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj = 0;
8680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8681 wxPoint2D *arg2 = 0 ;
8682 wxPoint2D *result = 0 ;
8683 void *argp1 = 0 ;
8684 int res1 = 0 ;
8685 wxPoint2D temp2 ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 char * kwnames[] = {
8689 (char *) "self",(char *) "pt", NULL
8690 };
8691
8692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8696 }
8697 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8698 {
8699 arg2 = &temp2;
8700 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8701 }
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 {
8705 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8706 result = (wxPoint2D *) &_result_ref;
8707 }
8708 wxPyEndAllowThreads(__tstate);
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj = 0;
8720 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8721 PyObject *arg2 = (PyObject *) 0 ;
8722 bool result;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "self",(char *) "other", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8735 }
8736 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8737 arg2 = obj1;
8738 {
8739 result = (bool)wxPoint2D___eq__(arg1,arg2);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 {
8743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8744 }
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj = 0;
8753 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8754 PyObject *arg2 = (PyObject *) 0 ;
8755 bool result;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "other", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8768 }
8769 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8770 arg2 = obj1;
8771 {
8772 result = (bool)wxPoint2D___ne__(arg1,arg2);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 {
8776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8777 }
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8785 PyObject *resultobj = 0;
8786 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8787 double arg2 ;
8788 void *argp1 = 0 ;
8789 int res1 = 0 ;
8790 double val2 ;
8791 int ecode2 = 0 ;
8792 PyObject *swig_obj[2] ;
8793
8794 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8796 if (!SWIG_IsOK(res1)) {
8797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8798 }
8799 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8800 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8801 if (!SWIG_IsOK(ecode2)) {
8802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8803 }
8804 arg2 = static_cast< double >(val2);
8805 if (arg1) (arg1)->m_x = arg2;
8806
8807 resultobj = SWIG_Py_Void();
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8815 PyObject *resultobj = 0;
8816 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8817 double result;
8818 void *argp1 = 0 ;
8819 int res1 = 0 ;
8820 PyObject *swig_obj[1] ;
8821
8822 if (!args) SWIG_fail;
8823 swig_obj[0] = args;
8824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8825 if (!SWIG_IsOK(res1)) {
8826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8827 }
8828 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8829 result = (double) ((arg1)->m_x);
8830 resultobj = SWIG_From_double(static_cast< double >(result));
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 PyObject *resultobj = 0;
8839 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8840 double arg2 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 double val2 ;
8844 int ecode2 = 0 ;
8845 PyObject *swig_obj[2] ;
8846
8847 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8851 }
8852 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8853 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8856 }
8857 arg2 = static_cast< double >(val2);
8858 if (arg1) (arg1)->m_y = arg2;
8859
8860 resultobj = SWIG_Py_Void();
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8868 PyObject *resultobj = 0;
8869 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8870 double result;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 PyObject *swig_obj[1] ;
8874
8875 if (!args) SWIG_fail;
8876 swig_obj[0] = args;
8877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8878 if (!SWIG_IsOK(res1)) {
8879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8880 }
8881 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8882 result = (double) ((arg1)->m_y);
8883 resultobj = SWIG_From_double(static_cast< double >(result));
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8893 double arg2 = (double) 0 ;
8894 double arg3 = (double) 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 double val2 ;
8898 int ecode2 = 0 ;
8899 double val3 ;
8900 int ecode3 = 0 ;
8901 PyObject * obj0 = 0 ;
8902 PyObject * obj1 = 0 ;
8903 PyObject * obj2 = 0 ;
8904 char * kwnames[] = {
8905 (char *) "self",(char *) "x",(char *) "y", NULL
8906 };
8907
8908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8910 if (!SWIG_IsOK(res1)) {
8911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8912 }
8913 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8914 if (obj1) {
8915 ecode2 = SWIG_AsVal_double(obj1, &val2);
8916 if (!SWIG_IsOK(ecode2)) {
8917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8918 }
8919 arg2 = static_cast< double >(val2);
8920 }
8921 if (obj2) {
8922 ecode3 = SWIG_AsVal_double(obj2, &val3);
8923 if (!SWIG_IsOK(ecode3)) {
8924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8925 }
8926 arg3 = static_cast< double >(val3);
8927 }
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 wxPoint2D_Set(arg1,arg2,arg3);
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_Py_Void();
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 PyObject *resultobj = 0;
8943 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8944 PyObject *result = 0 ;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 PyObject *swig_obj[1] ;
8948
8949 if (!args) SWIG_fail;
8950 swig_obj[0] = args;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 result = (PyObject *)wxPoint2D_Get(arg1);
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 resultobj = result;
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *obj;
8971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8972 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8973 return SWIG_Py_Void();
8974 }
8975
8976 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8977 return SWIG_Python_InitShadowInstance(args);
8978 }
8979
8980 SWIGINTERN int DefaultPosition_set(PyObject *) {
8981 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8982 return 1;
8983 }
8984
8985
8986 SWIGINTERN PyObject *DefaultPosition_get(void) {
8987 PyObject *pyobj = 0;
8988
8989 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8990 return pyobj;
8991 }
8992
8993
8994 SWIGINTERN int DefaultSize_set(PyObject *) {
8995 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8996 return 1;
8997 }
8998
8999
9000 SWIGINTERN PyObject *DefaultSize_get(void) {
9001 PyObject *pyobj = 0;
9002
9003 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9004 return pyobj;
9005 }
9006
9007
9008 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj = 0;
9010 PyObject *arg1 = (PyObject *) 0 ;
9011 wxPyInputStream *result = 0 ;
9012 PyObject * obj0 = 0 ;
9013 char * kwnames[] = {
9014 (char *) "p", NULL
9015 };
9016
9017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9018 arg1 = obj0;
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9026 return resultobj;
9027 fail:
9028 return NULL;
9029 }
9030
9031
9032 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9033 PyObject *resultobj = 0;
9034 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9035 void *argp1 = 0 ;
9036 int res1 = 0 ;
9037 PyObject *swig_obj[1] ;
9038
9039 if (!args) SWIG_fail;
9040 swig_obj[0] = args;
9041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9042 if (!SWIG_IsOK(res1)) {
9043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9044 }
9045 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9046 {
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 delete arg1;
9049
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 resultobj = SWIG_Py_Void();
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9061 PyObject *resultobj = 0;
9062 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 PyObject *swig_obj[1] ;
9066
9067 if (!args) SWIG_fail;
9068 swig_obj[0] = args;
9069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9070 if (!SWIG_IsOK(res1)) {
9071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9072 }
9073 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 (arg1)->close();
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_Py_Void();
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *resultobj = 0;
9089 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 PyObject *swig_obj[1] ;
9093
9094 if (!args) SWIG_fail;
9095 swig_obj[0] = args;
9096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9097 if (!SWIG_IsOK(res1)) {
9098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9099 }
9100 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 (arg1)->flush();
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_Py_Void();
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *resultobj = 0;
9116 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9117 bool result;
9118 void *argp1 = 0 ;
9119 int res1 = 0 ;
9120 PyObject *swig_obj[1] ;
9121
9122 if (!args) SWIG_fail;
9123 swig_obj[0] = args;
9124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9125 if (!SWIG_IsOK(res1)) {
9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9127 }
9128 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (bool)(arg1)->eof();
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 {
9136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9137 }
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9145 PyObject *resultobj = 0;
9146 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9147 int arg2 = (int) -1 ;
9148 PyObject *result = 0 ;
9149 void *argp1 = 0 ;
9150 int res1 = 0 ;
9151 int val2 ;
9152 int ecode2 = 0 ;
9153 PyObject * obj0 = 0 ;
9154 PyObject * obj1 = 0 ;
9155 char * kwnames[] = {
9156 (char *) "self",(char *) "size", NULL
9157 };
9158
9159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9163 }
9164 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9165 if (obj1) {
9166 ecode2 = SWIG_AsVal_int(obj1, &val2);
9167 if (!SWIG_IsOK(ecode2)) {
9168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9169 }
9170 arg2 = static_cast< int >(val2);
9171 }
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 result = (PyObject *)(arg1)->read(arg2);
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 resultobj = result;
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj = 0;
9187 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9188 int arg2 = (int) -1 ;
9189 PyObject *result = 0 ;
9190 void *argp1 = 0 ;
9191 int res1 = 0 ;
9192 int val2 ;
9193 int ecode2 = 0 ;
9194 PyObject * obj0 = 0 ;
9195 PyObject * obj1 = 0 ;
9196 char * kwnames[] = {
9197 (char *) "self",(char *) "size", NULL
9198 };
9199
9200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9202 if (!SWIG_IsOK(res1)) {
9203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9204 }
9205 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9206 if (obj1) {
9207 ecode2 = SWIG_AsVal_int(obj1, &val2);
9208 if (!SWIG_IsOK(ecode2)) {
9209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9210 }
9211 arg2 = static_cast< int >(val2);
9212 }
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (PyObject *)(arg1)->readline(arg2);
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = result;
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj = 0;
9228 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9229 int arg2 = (int) -1 ;
9230 PyObject *result = 0 ;
9231 void *argp1 = 0 ;
9232 int res1 = 0 ;
9233 int val2 ;
9234 int ecode2 = 0 ;
9235 PyObject * obj0 = 0 ;
9236 PyObject * obj1 = 0 ;
9237 char * kwnames[] = {
9238 (char *) "self",(char *) "sizehint", NULL
9239 };
9240
9241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9245 }
9246 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9247 if (obj1) {
9248 ecode2 = SWIG_AsVal_int(obj1, &val2);
9249 if (!SWIG_IsOK(ecode2)) {
9250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9251 }
9252 arg2 = static_cast< int >(val2);
9253 }
9254 {
9255 PyThreadState* __tstate = wxPyBeginAllowThreads();
9256 result = (PyObject *)(arg1)->readlines(arg2);
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 resultobj = result;
9261 return resultobj;
9262 fail:
9263 return NULL;
9264 }
9265
9266
9267 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj = 0;
9269 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9270 int arg2 ;
9271 int arg3 = (int) 0 ;
9272 void *argp1 = 0 ;
9273 int res1 = 0 ;
9274 int val2 ;
9275 int ecode2 = 0 ;
9276 int val3 ;
9277 int ecode3 = 0 ;
9278 PyObject * obj0 = 0 ;
9279 PyObject * obj1 = 0 ;
9280 PyObject * obj2 = 0 ;
9281 char * kwnames[] = {
9282 (char *) "self",(char *) "offset",(char *) "whence", NULL
9283 };
9284
9285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9287 if (!SWIG_IsOK(res1)) {
9288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9289 }
9290 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9291 ecode2 = SWIG_AsVal_int(obj1, &val2);
9292 if (!SWIG_IsOK(ecode2)) {
9293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9294 }
9295 arg2 = static_cast< int >(val2);
9296 if (obj2) {
9297 ecode3 = SWIG_AsVal_int(obj2, &val3);
9298 if (!SWIG_IsOK(ecode3)) {
9299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9300 }
9301 arg3 = static_cast< int >(val3);
9302 }
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 (arg1)->seek(arg2,arg3);
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 resultobj = SWIG_Py_Void();
9310 return resultobj;
9311 fail:
9312 return NULL;
9313 }
9314
9315
9316 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9317 PyObject *resultobj = 0;
9318 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9319 int result;
9320 void *argp1 = 0 ;
9321 int res1 = 0 ;
9322 PyObject *swig_obj[1] ;
9323
9324 if (!args) SWIG_fail;
9325 swig_obj[0] = args;
9326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9327 if (!SWIG_IsOK(res1)) {
9328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9329 }
9330 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 result = (int)(arg1)->tell();
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 resultobj = SWIG_From_int(static_cast< int >(result));
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9345 PyObject *resultobj = 0;
9346 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9347 char result;
9348 void *argp1 = 0 ;
9349 int res1 = 0 ;
9350 PyObject *swig_obj[1] ;
9351
9352 if (!args) SWIG_fail;
9353 swig_obj[0] = args;
9354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9355 if (!SWIG_IsOK(res1)) {
9356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9357 }
9358 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (char)(arg1)->Peek();
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_From_char(static_cast< char >(result));
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *resultobj = 0;
9374 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9375 char result;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 PyObject *swig_obj[1] ;
9379
9380 if (!args) SWIG_fail;
9381 swig_obj[0] = args;
9382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9383 if (!SWIG_IsOK(res1)) {
9384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9385 }
9386 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9387 {
9388 PyThreadState* __tstate = wxPyBeginAllowThreads();
9389 result = (char)(arg1)->GetC();
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 resultobj = SWIG_From_char(static_cast< char >(result));
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9401 PyObject *resultobj = 0;
9402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9403 size_t result;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 PyObject *swig_obj[1] ;
9407
9408 if (!args) SWIG_fail;
9409 swig_obj[0] = args;
9410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9413 }
9414 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (size_t)(arg1)->LastRead();
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9422 return resultobj;
9423 fail:
9424 return NULL;
9425 }
9426
9427
9428 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9429 PyObject *resultobj = 0;
9430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9431 bool result;
9432 void *argp1 = 0 ;
9433 int res1 = 0 ;
9434 PyObject *swig_obj[1] ;
9435
9436 if (!args) SWIG_fail;
9437 swig_obj[0] = args;
9438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9439 if (!SWIG_IsOK(res1)) {
9440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9441 }
9442 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 result = (bool)(arg1)->CanRead();
9446 wxPyEndAllowThreads(__tstate);
9447 if (PyErr_Occurred()) SWIG_fail;
9448 }
9449 {
9450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9451 }
9452 return resultobj;
9453 fail:
9454 return NULL;
9455 }
9456
9457
9458 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9459 PyObject *resultobj = 0;
9460 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9461 bool result;
9462 void *argp1 = 0 ;
9463 int res1 = 0 ;
9464 PyObject *swig_obj[1] ;
9465
9466 if (!args) SWIG_fail;
9467 swig_obj[0] = args;
9468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9471 }
9472 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9473 {
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = (bool)(arg1)->Eof();
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9481 }
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9491 char arg2 ;
9492 bool result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 char val2 ;
9496 int ecode2 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char * kwnames[] = {
9500 (char *) "self",(char *) "c", NULL
9501 };
9502
9503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9507 }
9508 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9509 ecode2 = SWIG_AsVal_char(obj1, &val2);
9510 if (!SWIG_IsOK(ecode2)) {
9511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9512 }
9513 arg2 = static_cast< char >(val2);
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 result = (bool)(arg1)->Ungetch(arg2);
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 {
9521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9522 }
9523 return resultobj;
9524 fail:
9525 return NULL;
9526 }
9527
9528
9529 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj = 0;
9531 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9532 long arg2 ;
9533 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9534 long result;
9535 void *argp1 = 0 ;
9536 int res1 = 0 ;
9537 long val2 ;
9538 int ecode2 = 0 ;
9539 int val3 ;
9540 int ecode3 = 0 ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 PyObject * obj2 = 0 ;
9544 char * kwnames[] = {
9545 (char *) "self",(char *) "pos",(char *) "mode", NULL
9546 };
9547
9548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9550 if (!SWIG_IsOK(res1)) {
9551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9552 }
9553 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9554 ecode2 = SWIG_AsVal_long(obj1, &val2);
9555 if (!SWIG_IsOK(ecode2)) {
9556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9557 }
9558 arg2 = static_cast< long >(val2);
9559 if (obj2) {
9560 ecode3 = SWIG_AsVal_int(obj2, &val3);
9561 if (!SWIG_IsOK(ecode3)) {
9562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9563 }
9564 arg3 = static_cast< wxSeekMode >(val3);
9565 }
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 result = (long)(arg1)->SeekI(arg2,arg3);
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 resultobj = SWIG_From_long(static_cast< long >(result));
9573 return resultobj;
9574 fail:
9575 return NULL;
9576 }
9577
9578
9579 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9580 PyObject *resultobj = 0;
9581 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9582 long result;
9583 void *argp1 = 0 ;
9584 int res1 = 0 ;
9585 PyObject *swig_obj[1] ;
9586
9587 if (!args) SWIG_fail;
9588 swig_obj[0] = args;
9589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9590 if (!SWIG_IsOK(res1)) {
9591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9592 }
9593 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 result = (long)(arg1)->TellI();
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_From_long(static_cast< long >(result));
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *obj;
9609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9610 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9611 return SWIG_Py_Void();
9612 }
9613
9614 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9615 return SWIG_Python_InitShadowInstance(args);
9616 }
9617
9618 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj = 0;
9620 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9621 PyObject *arg2 = (PyObject *) 0 ;
9622 void *argp1 = 0 ;
9623 int res1 = 0 ;
9624 PyObject * obj0 = 0 ;
9625 PyObject * obj1 = 0 ;
9626 char * kwnames[] = {
9627 (char *) "self",(char *) "obj", NULL
9628 };
9629
9630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9632 if (!SWIG_IsOK(res1)) {
9633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9634 }
9635 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9636 arg2 = obj1;
9637 {
9638 PyThreadState* __tstate = wxPyBeginAllowThreads();
9639 wxOutputStream_write(arg1,arg2);
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 resultobj = SWIG_Py_Void();
9644 return resultobj;
9645 fail:
9646 return NULL;
9647 }
9648
9649
9650 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9651 PyObject *resultobj = 0;
9652 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9653 size_t result;
9654 void *argp1 = 0 ;
9655 int res1 = 0 ;
9656 PyObject *swig_obj[1] ;
9657
9658 if (!args) SWIG_fail;
9659 swig_obj[0] = args;
9660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9661 if (!SWIG_IsOK(res1)) {
9662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9663 }
9664 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9672 return resultobj;
9673 fail:
9674 return NULL;
9675 }
9676
9677
9678 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9679 PyObject *obj;
9680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9681 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9682 return SWIG_Py_Void();
9683 }
9684
9685 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj = 0;
9687 wxInputStream *arg1 = (wxInputStream *) 0 ;
9688 wxString *arg2 = 0 ;
9689 wxString *arg3 = 0 ;
9690 wxString *arg4 = 0 ;
9691 wxDateTime arg5 ;
9692 wxFSFile *result = 0 ;
9693 wxPyInputStream *temp1 ;
9694 bool temp2 = false ;
9695 bool temp3 = false ;
9696 bool temp4 = false ;
9697 void *argp5 ;
9698 int res5 = 0 ;
9699 PyObject * obj0 = 0 ;
9700 PyObject * obj1 = 0 ;
9701 PyObject * obj2 = 0 ;
9702 PyObject * obj3 = 0 ;
9703 PyObject * obj4 = 0 ;
9704 char * kwnames[] = {
9705 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9706 };
9707
9708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9709 {
9710 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9711 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9712 } else {
9713 PyErr_Clear(); // clear the failure of the wxPyConvert above
9714 arg1 = wxPyCBInputStream_create(obj0, true);
9715 if (arg1 == NULL) {
9716 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9717 SWIG_fail;
9718 }
9719 }
9720 }
9721 {
9722 arg2 = wxString_in_helper(obj1);
9723 if (arg2 == NULL) SWIG_fail;
9724 temp2 = true;
9725 }
9726 {
9727 arg3 = wxString_in_helper(obj2);
9728 if (arg3 == NULL) SWIG_fail;
9729 temp3 = true;
9730 }
9731 {
9732 arg4 = wxString_in_helper(obj3);
9733 if (arg4 == NULL) SWIG_fail;
9734 temp4 = true;
9735 }
9736 {
9737 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9738 if (!SWIG_IsOK(res5)) {
9739 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9740 }
9741 if (!argp5) {
9742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9743 } else {
9744 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9745 arg5 = *temp;
9746 if (SWIG_IsNewObj(res5)) delete temp;
9747 }
9748 }
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9756 {
9757 if (temp2)
9758 delete arg2;
9759 }
9760 {
9761 if (temp3)
9762 delete arg3;
9763 }
9764 {
9765 if (temp4)
9766 delete arg4;
9767 }
9768 return resultobj;
9769 fail:
9770 {
9771 if (temp2)
9772 delete arg2;
9773 }
9774 {
9775 if (temp3)
9776 delete arg3;
9777 }
9778 {
9779 if (temp4)
9780 delete arg4;
9781 }
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9787 PyObject *resultobj = 0;
9788 wxFSFile *arg1 = (wxFSFile *) 0 ;
9789 void *argp1 = 0 ;
9790 int res1 = 0 ;
9791 PyObject *swig_obj[1] ;
9792
9793 if (!args) SWIG_fail;
9794 swig_obj[0] = args;
9795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9798 }
9799 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 delete arg1;
9803
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 resultobj = SWIG_Py_Void();
9808 return resultobj;
9809 fail:
9810 return NULL;
9811 }
9812
9813
9814 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9815 PyObject *resultobj = 0;
9816 wxFSFile *arg1 = (wxFSFile *) 0 ;
9817 wxInputStream *result = 0 ;
9818 void *argp1 = 0 ;
9819 int res1 = 0 ;
9820 PyObject *swig_obj[1] ;
9821
9822 if (!args) SWIG_fail;
9823 swig_obj[0] = args;
9824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9825 if (!SWIG_IsOK(res1)) {
9826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9827 }
9828 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (wxInputStream *)(arg1)->GetStream();
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 {
9836 wxPyInputStream * _ptr = NULL;
9837
9838 if (result) {
9839 _ptr = new wxPyInputStream(result);
9840 }
9841 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9842 }
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9850 PyObject *resultobj = 0;
9851 wxFSFile *arg1 = (wxFSFile *) 0 ;
9852 wxString *result = 0 ;
9853 void *argp1 = 0 ;
9854 int res1 = 0 ;
9855 PyObject *swig_obj[1] ;
9856
9857 if (!args) SWIG_fail;
9858 swig_obj[0] = args;
9859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9860 if (!SWIG_IsOK(res1)) {
9861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9862 }
9863 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9864 {
9865 PyThreadState* __tstate = wxPyBeginAllowThreads();
9866 {
9867 wxString const &_result_ref = (arg1)->GetMimeType();
9868 result = (wxString *) &_result_ref;
9869 }
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 #if wxUSE_UNICODE
9875 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9876 #else
9877 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9878 #endif
9879 }
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887 PyObject *resultobj = 0;
9888 wxFSFile *arg1 = (wxFSFile *) 0 ;
9889 wxString *result = 0 ;
9890 void *argp1 = 0 ;
9891 int res1 = 0 ;
9892 PyObject *swig_obj[1] ;
9893
9894 if (!args) SWIG_fail;
9895 swig_obj[0] = args;
9896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9897 if (!SWIG_IsOK(res1)) {
9898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9899 }
9900 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 {
9904 wxString const &_result_ref = (arg1)->GetLocation();
9905 result = (wxString *) &_result_ref;
9906 }
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 {
9911 #if wxUSE_UNICODE
9912 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9913 #else
9914 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9915 #endif
9916 }
9917 return resultobj;
9918 fail:
9919 return NULL;
9920 }
9921
9922
9923 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9924 PyObject *resultobj = 0;
9925 wxFSFile *arg1 = (wxFSFile *) 0 ;
9926 wxString *result = 0 ;
9927 void *argp1 = 0 ;
9928 int res1 = 0 ;
9929 PyObject *swig_obj[1] ;
9930
9931 if (!args) SWIG_fail;
9932 swig_obj[0] = args;
9933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9934 if (!SWIG_IsOK(res1)) {
9935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9936 }
9937 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 {
9941 wxString const &_result_ref = (arg1)->GetAnchor();
9942 result = (wxString *) &_result_ref;
9943 }
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 {
9948 #if wxUSE_UNICODE
9949 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9950 #else
9951 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9952 #endif
9953 }
9954 return resultobj;
9955 fail:
9956 return NULL;
9957 }
9958
9959
9960 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9961 PyObject *resultobj = 0;
9962 wxFSFile *arg1 = (wxFSFile *) 0 ;
9963 wxDateTime result;
9964 void *argp1 = 0 ;
9965 int res1 = 0 ;
9966 PyObject *swig_obj[1] ;
9967
9968 if (!args) SWIG_fail;
9969 swig_obj[0] = args;
9970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9971 if (!SWIG_IsOK(res1)) {
9972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9973 }
9974 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = (arg1)->GetModificationTime();
9978 wxPyEndAllowThreads(__tstate);
9979 if (PyErr_Occurred()) SWIG_fail;
9980 }
9981 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9982 return resultobj;
9983 fail:
9984 return NULL;
9985 }
9986
9987
9988 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9989 PyObject *obj;
9990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9991 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9992 return SWIG_Py_Void();
9993 }
9994
9995 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9996 return SWIG_Python_InitShadowInstance(args);
9997 }
9998
9999 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10000 PyObject *resultobj = 0;
10001 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10002 void *argp1 = 0 ;
10003 int res1 = 0 ;
10004 PyObject *swig_obj[1] ;
10005
10006 if (!args) SWIG_fail;
10007 swig_obj[0] = args;
10008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10009 if (!SWIG_IsOK(res1)) {
10010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10011 }
10012 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 delete arg1;
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_Py_Void();
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *obj;
10029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10030 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10031 return SWIG_Py_Void();
10032 }
10033
10034 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10035 PyObject *resultobj = 0;
10036 wxPyFileSystemHandler *result = 0 ;
10037
10038 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10039 {
10040 PyThreadState* __tstate = wxPyBeginAllowThreads();
10041 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10046 return resultobj;
10047 fail:
10048 return NULL;
10049 }
10050
10051
10052 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10053 PyObject *resultobj = 0;
10054 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10055 PyObject *arg2 = (PyObject *) 0 ;
10056 PyObject *arg3 = (PyObject *) 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 PyObject * obj2 = 0 ;
10062 char * kwnames[] = {
10063 (char *) "self",(char *) "self",(char *) "_class", NULL
10064 };
10065
10066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10070 }
10071 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10072 arg2 = obj1;
10073 arg3 = obj2;
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 (arg1)->_setCallbackInfo(arg2,arg3);
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 resultobj = SWIG_Py_Void();
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10090 wxString *arg2 = 0 ;
10091 bool result;
10092 void *argp1 = 0 ;
10093 int res1 = 0 ;
10094 bool temp2 = false ;
10095 PyObject * obj0 = 0 ;
10096 PyObject * obj1 = 0 ;
10097 char * kwnames[] = {
10098 (char *) "self",(char *) "location", NULL
10099 };
10100
10101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10103 if (!SWIG_IsOK(res1)) {
10104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10105 }
10106 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10107 {
10108 arg2 = wxString_in_helper(obj1);
10109 if (arg2 == NULL) SWIG_fail;
10110 temp2 = true;
10111 }
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 {
10119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10120 }
10121 {
10122 if (temp2)
10123 delete arg2;
10124 }
10125 return resultobj;
10126 fail:
10127 {
10128 if (temp2)
10129 delete arg2;
10130 }
10131 return NULL;
10132 }
10133
10134
10135 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10136 PyObject *resultobj = 0;
10137 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10138 wxFileSystem *arg2 = 0 ;
10139 wxString *arg3 = 0 ;
10140 wxFSFile *result = 0 ;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 void *argp2 = 0 ;
10144 int res2 = 0 ;
10145 bool temp3 = false ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 PyObject * obj2 = 0 ;
10149 char * kwnames[] = {
10150 (char *) "self",(char *) "fs",(char *) "location", NULL
10151 };
10152
10153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10157 }
10158 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10160 if (!SWIG_IsOK(res2)) {
10161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10162 }
10163 if (!argp2) {
10164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10165 }
10166 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10167 {
10168 arg3 = wxString_in_helper(obj2);
10169 if (arg3 == NULL) SWIG_fail;
10170 temp3 = true;
10171 }
10172 {
10173 PyThreadState* __tstate = wxPyBeginAllowThreads();
10174 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 {
10179 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10180 }
10181 {
10182 if (temp3)
10183 delete arg3;
10184 }
10185 return resultobj;
10186 fail:
10187 {
10188 if (temp3)
10189 delete arg3;
10190 }
10191 return NULL;
10192 }
10193
10194
10195 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10196 PyObject *resultobj = 0;
10197 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10198 wxString *arg2 = 0 ;
10199 int arg3 = (int) 0 ;
10200 wxString result;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 bool temp2 = false ;
10204 int val3 ;
10205 int ecode3 = 0 ;
10206 PyObject * obj0 = 0 ;
10207 PyObject * obj1 = 0 ;
10208 PyObject * obj2 = 0 ;
10209 char * kwnames[] = {
10210 (char *) "self",(char *) "spec",(char *) "flags", NULL
10211 };
10212
10213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10215 if (!SWIG_IsOK(res1)) {
10216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10217 }
10218 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10219 {
10220 arg2 = wxString_in_helper(obj1);
10221 if (arg2 == NULL) SWIG_fail;
10222 temp2 = true;
10223 }
10224 if (obj2) {
10225 ecode3 = SWIG_AsVal_int(obj2, &val3);
10226 if (!SWIG_IsOK(ecode3)) {
10227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10228 }
10229 arg3 = static_cast< int >(val3);
10230 }
10231 {
10232 PyThreadState* __tstate = wxPyBeginAllowThreads();
10233 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 {
10238 #if wxUSE_UNICODE
10239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10240 #else
10241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10242 #endif
10243 }
10244 {
10245 if (temp2)
10246 delete arg2;
10247 }
10248 return resultobj;
10249 fail:
10250 {
10251 if (temp2)
10252 delete arg2;
10253 }
10254 return NULL;
10255 }
10256
10257
10258 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10259 PyObject *resultobj = 0;
10260 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10261 wxString result;
10262 void *argp1 = 0 ;
10263 int res1 = 0 ;
10264 PyObject *swig_obj[1] ;
10265
10266 if (!args) SWIG_fail;
10267 swig_obj[0] = args;
10268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10271 }
10272 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10273 {
10274 PyThreadState* __tstate = wxPyBeginAllowThreads();
10275 result = (arg1)->FindNext();
10276 wxPyEndAllowThreads(__tstate);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 {
10280 #if wxUSE_UNICODE
10281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10282 #else
10283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10284 #endif
10285 }
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10293 PyObject *resultobj = 0;
10294 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10295 wxString *arg2 = 0 ;
10296 wxString result;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 bool temp2 = false ;
10300 PyObject * obj0 = 0 ;
10301 PyObject * obj1 = 0 ;
10302 char * kwnames[] = {
10303 (char *) "self",(char *) "location", NULL
10304 };
10305
10306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10308 if (!SWIG_IsOK(res1)) {
10309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10310 }
10311 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10312 {
10313 arg2 = wxString_in_helper(obj1);
10314 if (arg2 == NULL) SWIG_fail;
10315 temp2 = true;
10316 }
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = (arg1)->GetProtocol((wxString const &)*arg2);
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 {
10331 if (temp2)
10332 delete arg2;
10333 }
10334 return resultobj;
10335 fail:
10336 {
10337 if (temp2)
10338 delete arg2;
10339 }
10340 return NULL;
10341 }
10342
10343
10344 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10345 PyObject *resultobj = 0;
10346 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10347 wxString *arg2 = 0 ;
10348 wxString result;
10349 void *argp1 = 0 ;
10350 int res1 = 0 ;
10351 bool temp2 = false ;
10352 PyObject * obj0 = 0 ;
10353 PyObject * obj1 = 0 ;
10354 char * kwnames[] = {
10355 (char *) "self",(char *) "location", NULL
10356 };
10357
10358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10360 if (!SWIG_IsOK(res1)) {
10361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10362 }
10363 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10364 {
10365 arg2 = wxString_in_helper(obj1);
10366 if (arg2 == NULL) SWIG_fail;
10367 temp2 = true;
10368 }
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 {
10376 #if wxUSE_UNICODE
10377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10378 #else
10379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10380 #endif
10381 }
10382 {
10383 if (temp2)
10384 delete arg2;
10385 }
10386 return resultobj;
10387 fail:
10388 {
10389 if (temp2)
10390 delete arg2;
10391 }
10392 return NULL;
10393 }
10394
10395
10396 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10397 PyObject *resultobj = 0;
10398 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10399 wxString *arg2 = 0 ;
10400 wxString result;
10401 void *argp1 = 0 ;
10402 int res1 = 0 ;
10403 bool temp2 = false ;
10404 PyObject * obj0 = 0 ;
10405 PyObject * obj1 = 0 ;
10406 char * kwnames[] = {
10407 (char *) "self",(char *) "location", NULL
10408 };
10409
10410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10412 if (!SWIG_IsOK(res1)) {
10413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10414 }
10415 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10416 {
10417 arg2 = wxString_in_helper(obj1);
10418 if (arg2 == NULL) SWIG_fail;
10419 temp2 = true;
10420 }
10421 {
10422 PyThreadState* __tstate = wxPyBeginAllowThreads();
10423 result = (arg1)->GetAnchor((wxString const &)*arg2);
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 {
10428 #if wxUSE_UNICODE
10429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10430 #else
10431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10432 #endif
10433 }
10434 {
10435 if (temp2)
10436 delete arg2;
10437 }
10438 return resultobj;
10439 fail:
10440 {
10441 if (temp2)
10442 delete arg2;
10443 }
10444 return NULL;
10445 }
10446
10447
10448 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10449 PyObject *resultobj = 0;
10450 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10451 wxString *arg2 = 0 ;
10452 wxString result;
10453 void *argp1 = 0 ;
10454 int res1 = 0 ;
10455 bool temp2 = false ;
10456 PyObject * obj0 = 0 ;
10457 PyObject * obj1 = 0 ;
10458 char * kwnames[] = {
10459 (char *) "self",(char *) "location", NULL
10460 };
10461
10462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10466 }
10467 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10468 {
10469 arg2 = wxString_in_helper(obj1);
10470 if (arg2 == NULL) SWIG_fail;
10471 temp2 = true;
10472 }
10473 {
10474 PyThreadState* __tstate = wxPyBeginAllowThreads();
10475 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10476 wxPyEndAllowThreads(__tstate);
10477 if (PyErr_Occurred()) SWIG_fail;
10478 }
10479 {
10480 #if wxUSE_UNICODE
10481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10482 #else
10483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10484 #endif
10485 }
10486 {
10487 if (temp2)
10488 delete arg2;
10489 }
10490 return resultobj;
10491 fail:
10492 {
10493 if (temp2)
10494 delete arg2;
10495 }
10496 return NULL;
10497 }
10498
10499
10500 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10501 PyObject *resultobj = 0;
10502 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10503 wxString *arg2 = 0 ;
10504 wxString result;
10505 void *argp1 = 0 ;
10506 int res1 = 0 ;
10507 bool temp2 = false ;
10508 PyObject * obj0 = 0 ;
10509 PyObject * obj1 = 0 ;
10510 char * kwnames[] = {
10511 (char *) "self",(char *) "location", NULL
10512 };
10513
10514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10516 if (!SWIG_IsOK(res1)) {
10517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10518 }
10519 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10520 {
10521 arg2 = wxString_in_helper(obj1);
10522 if (arg2 == NULL) SWIG_fail;
10523 temp2 = true;
10524 }
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 #if wxUSE_UNICODE
10533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10534 #else
10535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10536 #endif
10537 }
10538 {
10539 if (temp2)
10540 delete arg2;
10541 }
10542 return resultobj;
10543 fail:
10544 {
10545 if (temp2)
10546 delete arg2;
10547 }
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10553 PyObject *obj;
10554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10555 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10556 return SWIG_Py_Void();
10557 }
10558
10559 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10560 return SWIG_Python_InitShadowInstance(args);
10561 }
10562
10563 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10564 PyObject *resultobj = 0;
10565 wxFileSystem *result = 0 ;
10566
10567 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (wxFileSystem *)new wxFileSystem();
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10576 }
10577 return resultobj;
10578 fail:
10579 return NULL;
10580 }
10581
10582
10583 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10584 PyObject *resultobj = 0;
10585 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10586 void *argp1 = 0 ;
10587 int res1 = 0 ;
10588 PyObject *swig_obj[1] ;
10589
10590 if (!args) SWIG_fail;
10591 swig_obj[0] = args;
10592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10593 if (!SWIG_IsOK(res1)) {
10594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10595 }
10596 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10597 {
10598 PyThreadState* __tstate = wxPyBeginAllowThreads();
10599 delete arg1;
10600
10601 wxPyEndAllowThreads(__tstate);
10602 if (PyErr_Occurred()) SWIG_fail;
10603 }
10604 resultobj = SWIG_Py_Void();
10605 return resultobj;
10606 fail:
10607 return NULL;
10608 }
10609
10610
10611 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10612 PyObject *resultobj = 0;
10613 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10614 wxString *arg2 = 0 ;
10615 bool arg3 = (bool) false ;
10616 void *argp1 = 0 ;
10617 int res1 = 0 ;
10618 bool temp2 = false ;
10619 bool val3 ;
10620 int ecode3 = 0 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 PyObject * obj2 = 0 ;
10624 char * kwnames[] = {
10625 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10626 };
10627
10628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10630 if (!SWIG_IsOK(res1)) {
10631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10632 }
10633 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10634 {
10635 arg2 = wxString_in_helper(obj1);
10636 if (arg2 == NULL) SWIG_fail;
10637 temp2 = true;
10638 }
10639 if (obj2) {
10640 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10641 if (!SWIG_IsOK(ecode3)) {
10642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10643 }
10644 arg3 = static_cast< bool >(val3);
10645 }
10646 {
10647 PyThreadState* __tstate = wxPyBeginAllowThreads();
10648 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10649 wxPyEndAllowThreads(__tstate);
10650 if (PyErr_Occurred()) SWIG_fail;
10651 }
10652 resultobj = SWIG_Py_Void();
10653 {
10654 if (temp2)
10655 delete arg2;
10656 }
10657 return resultobj;
10658 fail:
10659 {
10660 if (temp2)
10661 delete arg2;
10662 }
10663 return NULL;
10664 }
10665
10666
10667 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10668 PyObject *resultobj = 0;
10669 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10670 wxString result;
10671 void *argp1 = 0 ;
10672 int res1 = 0 ;
10673 PyObject *swig_obj[1] ;
10674
10675 if (!args) SWIG_fail;
10676 swig_obj[0] = args;
10677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10678 if (!SWIG_IsOK(res1)) {
10679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10680 }
10681 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10682 {
10683 PyThreadState* __tstate = wxPyBeginAllowThreads();
10684 result = (arg1)->GetPath();
10685 wxPyEndAllowThreads(__tstate);
10686 if (PyErr_Occurred()) SWIG_fail;
10687 }
10688 {
10689 #if wxUSE_UNICODE
10690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10691 #else
10692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10693 #endif
10694 }
10695 return resultobj;
10696 fail:
10697 return NULL;
10698 }
10699
10700
10701 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10702 PyObject *resultobj = 0;
10703 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10704 wxString *arg2 = 0 ;
10705 wxFSFile *result = 0 ;
10706 void *argp1 = 0 ;
10707 int res1 = 0 ;
10708 bool temp2 = false ;
10709 PyObject * obj0 = 0 ;
10710 PyObject * obj1 = 0 ;
10711 char * kwnames[] = {
10712 (char *) "self",(char *) "location", NULL
10713 };
10714
10715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10717 if (!SWIG_IsOK(res1)) {
10718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10719 }
10720 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10721 {
10722 arg2 = wxString_in_helper(obj1);
10723 if (arg2 == NULL) SWIG_fail;
10724 temp2 = true;
10725 }
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 {
10733 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10734 }
10735 {
10736 if (temp2)
10737 delete arg2;
10738 }
10739 return resultobj;
10740 fail:
10741 {
10742 if (temp2)
10743 delete arg2;
10744 }
10745 return NULL;
10746 }
10747
10748
10749 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj = 0;
10751 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10752 wxString *arg2 = 0 ;
10753 int arg3 = (int) 0 ;
10754 wxString result;
10755 void *argp1 = 0 ;
10756 int res1 = 0 ;
10757 bool temp2 = false ;
10758 int val3 ;
10759 int ecode3 = 0 ;
10760 PyObject * obj0 = 0 ;
10761 PyObject * obj1 = 0 ;
10762 PyObject * obj2 = 0 ;
10763 char * kwnames[] = {
10764 (char *) "self",(char *) "spec",(char *) "flags", NULL
10765 };
10766
10767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10769 if (!SWIG_IsOK(res1)) {
10770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10771 }
10772 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10773 {
10774 arg2 = wxString_in_helper(obj1);
10775 if (arg2 == NULL) SWIG_fail;
10776 temp2 = true;
10777 }
10778 if (obj2) {
10779 ecode3 = SWIG_AsVal_int(obj2, &val3);
10780 if (!SWIG_IsOK(ecode3)) {
10781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10782 }
10783 arg3 = static_cast< int >(val3);
10784 }
10785 {
10786 PyThreadState* __tstate = wxPyBeginAllowThreads();
10787 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 {
10792 #if wxUSE_UNICODE
10793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10794 #else
10795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10796 #endif
10797 }
10798 {
10799 if (temp2)
10800 delete arg2;
10801 }
10802 return resultobj;
10803 fail:
10804 {
10805 if (temp2)
10806 delete arg2;
10807 }
10808 return NULL;
10809 }
10810
10811
10812 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10813 PyObject *resultobj = 0;
10814 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10815 wxString result;
10816 void *argp1 = 0 ;
10817 int res1 = 0 ;
10818 PyObject *swig_obj[1] ;
10819
10820 if (!args) SWIG_fail;
10821 swig_obj[0] = args;
10822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10823 if (!SWIG_IsOK(res1)) {
10824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10825 }
10826 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10827 {
10828 PyThreadState* __tstate = wxPyBeginAllowThreads();
10829 result = (arg1)->FindNext();
10830 wxPyEndAllowThreads(__tstate);
10831 if (PyErr_Occurred()) SWIG_fail;
10832 }
10833 {
10834 #if wxUSE_UNICODE
10835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10836 #else
10837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10838 #endif
10839 }
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj = 0;
10848 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10849 int res1 = 0 ;
10850 PyObject * obj0 = 0 ;
10851 char * kwnames[] = {
10852 (char *) "handler", NULL
10853 };
10854
10855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10856 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10857 if (!SWIG_IsOK(res1)) {
10858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10859 }
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 wxFileSystem::AddHandler(arg1);
10863 wxPyEndAllowThreads(__tstate);
10864 if (PyErr_Occurred()) SWIG_fail;
10865 }
10866 resultobj = SWIG_Py_Void();
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10874 PyObject *resultobj = 0;
10875
10876 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10877 {
10878 PyThreadState* __tstate = wxPyBeginAllowThreads();
10879 wxFileSystem::CleanUpHandlers();
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxString *arg1 = 0 ;
10893 wxString result;
10894 bool temp1 = false ;
10895 PyObject * obj0 = 0 ;
10896 char * kwnames[] = {
10897 (char *) "filename", NULL
10898 };
10899
10900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10901 {
10902 arg1 = wxString_in_helper(obj0);
10903 if (arg1 == NULL) SWIG_fail;
10904 temp1 = true;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 #if wxUSE_UNICODE
10914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10915 #else
10916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10917 #endif
10918 }
10919 {
10920 if (temp1)
10921 delete arg1;
10922 }
10923 return resultobj;
10924 fail:
10925 {
10926 if (temp1)
10927 delete arg1;
10928 }
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj = 0;
10935 wxString *arg1 = 0 ;
10936 wxString result;
10937 bool temp1 = false ;
10938 PyObject * obj0 = 0 ;
10939 char * kwnames[] = {
10940 (char *) "url", NULL
10941 };
10942
10943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10944 {
10945 arg1 = wxString_in_helper(obj0);
10946 if (arg1 == NULL) SWIG_fail;
10947 temp1 = true;
10948 }
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 {
10956 #if wxUSE_UNICODE
10957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10958 #else
10959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10960 #endif
10961 }
10962 {
10963 if (temp1)
10964 delete arg1;
10965 }
10966 return resultobj;
10967 fail:
10968 {
10969 if (temp1)
10970 delete arg1;
10971 }
10972 return NULL;
10973 }
10974
10975
10976 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10977 PyObject *obj;
10978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10979 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10980 return SWIG_Py_Void();
10981 }
10982
10983 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10984 return SWIG_Python_InitShadowInstance(args);
10985 }
10986
10987 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10988 PyObject *resultobj = 0;
10989 wxInternetFSHandler *result = 0 ;
10990
10991 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10992 {
10993 PyThreadState* __tstate = wxPyBeginAllowThreads();
10994 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10999 return resultobj;
11000 fail:
11001 return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11006 PyObject *resultobj = 0;
11007 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11008 wxString *arg2 = 0 ;
11009 bool result;
11010 void *argp1 = 0 ;
11011 int res1 = 0 ;
11012 bool temp2 = false ;
11013 PyObject * obj0 = 0 ;
11014 PyObject * obj1 = 0 ;
11015 char * kwnames[] = {
11016 (char *) "self",(char *) "location", NULL
11017 };
11018
11019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11021 if (!SWIG_IsOK(res1)) {
11022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11023 }
11024 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11025 {
11026 arg2 = wxString_in_helper(obj1);
11027 if (arg2 == NULL) SWIG_fail;
11028 temp2 = true;
11029 }
11030 {
11031 PyThreadState* __tstate = wxPyBeginAllowThreads();
11032 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 {
11037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11038 }
11039 {
11040 if (temp2)
11041 delete arg2;
11042 }
11043 return resultobj;
11044 fail:
11045 {
11046 if (temp2)
11047 delete arg2;
11048 }
11049 return NULL;
11050 }
11051
11052
11053 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11054 PyObject *resultobj = 0;
11055 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11056 wxFileSystem *arg2 = 0 ;
11057 wxString *arg3 = 0 ;
11058 wxFSFile *result = 0 ;
11059 void *argp1 = 0 ;
11060 int res1 = 0 ;
11061 void *argp2 = 0 ;
11062 int res2 = 0 ;
11063 bool temp3 = false ;
11064 PyObject * obj0 = 0 ;
11065 PyObject * obj1 = 0 ;
11066 PyObject * obj2 = 0 ;
11067 char * kwnames[] = {
11068 (char *) "self",(char *) "fs",(char *) "location", NULL
11069 };
11070
11071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11073 if (!SWIG_IsOK(res1)) {
11074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11075 }
11076 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11078 if (!SWIG_IsOK(res2)) {
11079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11080 }
11081 if (!argp2) {
11082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11083 }
11084 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11085 {
11086 arg3 = wxString_in_helper(obj2);
11087 if (arg3 == NULL) SWIG_fail;
11088 temp3 = true;
11089 }
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11093 wxPyEndAllowThreads(__tstate);
11094 if (PyErr_Occurred()) SWIG_fail;
11095 }
11096 {
11097 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11098 }
11099 {
11100 if (temp3)
11101 delete arg3;
11102 }
11103 return resultobj;
11104 fail:
11105 {
11106 if (temp3)
11107 delete arg3;
11108 }
11109 return NULL;
11110 }
11111
11112
11113 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11114 PyObject *obj;
11115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11116 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11117 return SWIG_Py_Void();
11118 }
11119
11120 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11121 return SWIG_Python_InitShadowInstance(args);
11122 }
11123
11124 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11125 PyObject *resultobj = 0;
11126 wxZipFSHandler *result = 0 ;
11127
11128 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11129 {
11130 PyThreadState* __tstate = wxPyBeginAllowThreads();
11131 result = (wxZipFSHandler *)new wxZipFSHandler();
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11136 return resultobj;
11137 fail:
11138 return NULL;
11139 }
11140
11141
11142 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11143 PyObject *resultobj = 0;
11144 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11145 wxString *arg2 = 0 ;
11146 bool result;
11147 void *argp1 = 0 ;
11148 int res1 = 0 ;
11149 bool temp2 = false ;
11150 PyObject * obj0 = 0 ;
11151 PyObject * obj1 = 0 ;
11152 char * kwnames[] = {
11153 (char *) "self",(char *) "location", NULL
11154 };
11155
11156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11158 if (!SWIG_IsOK(res1)) {
11159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11160 }
11161 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11162 {
11163 arg2 = wxString_in_helper(obj1);
11164 if (arg2 == NULL) SWIG_fail;
11165 temp2 = true;
11166 }
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 {
11174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11175 }
11176 {
11177 if (temp2)
11178 delete arg2;
11179 }
11180 return resultobj;
11181 fail:
11182 {
11183 if (temp2)
11184 delete arg2;
11185 }
11186 return NULL;
11187 }
11188
11189
11190 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj = 0;
11192 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11193 wxFileSystem *arg2 = 0 ;
11194 wxString *arg3 = 0 ;
11195 wxFSFile *result = 0 ;
11196 void *argp1 = 0 ;
11197 int res1 = 0 ;
11198 void *argp2 = 0 ;
11199 int res2 = 0 ;
11200 bool temp3 = false ;
11201 PyObject * obj0 = 0 ;
11202 PyObject * obj1 = 0 ;
11203 PyObject * obj2 = 0 ;
11204 char * kwnames[] = {
11205 (char *) "self",(char *) "fs",(char *) "location", NULL
11206 };
11207
11208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11210 if (!SWIG_IsOK(res1)) {
11211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11212 }
11213 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11214 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11215 if (!SWIG_IsOK(res2)) {
11216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11217 }
11218 if (!argp2) {
11219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11220 }
11221 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11222 {
11223 arg3 = wxString_in_helper(obj2);
11224 if (arg3 == NULL) SWIG_fail;
11225 temp3 = true;
11226 }
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 {
11234 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11235 }
11236 {
11237 if (temp3)
11238 delete arg3;
11239 }
11240 return resultobj;
11241 fail:
11242 {
11243 if (temp3)
11244 delete arg3;
11245 }
11246 return NULL;
11247 }
11248
11249
11250 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11251 PyObject *resultobj = 0;
11252 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11253 wxString *arg2 = 0 ;
11254 int arg3 = (int) 0 ;
11255 wxString result;
11256 void *argp1 = 0 ;
11257 int res1 = 0 ;
11258 bool temp2 = false ;
11259 int val3 ;
11260 int ecode3 = 0 ;
11261 PyObject * obj0 = 0 ;
11262 PyObject * obj1 = 0 ;
11263 PyObject * obj2 = 0 ;
11264 char * kwnames[] = {
11265 (char *) "self",(char *) "spec",(char *) "flags", NULL
11266 };
11267
11268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11270 if (!SWIG_IsOK(res1)) {
11271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11272 }
11273 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11274 {
11275 arg2 = wxString_in_helper(obj1);
11276 if (arg2 == NULL) SWIG_fail;
11277 temp2 = true;
11278 }
11279 if (obj2) {
11280 ecode3 = SWIG_AsVal_int(obj2, &val3);
11281 if (!SWIG_IsOK(ecode3)) {
11282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11283 }
11284 arg3 = static_cast< int >(val3);
11285 }
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 {
11293 #if wxUSE_UNICODE
11294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11295 #else
11296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11297 #endif
11298 }
11299 {
11300 if (temp2)
11301 delete arg2;
11302 }
11303 return resultobj;
11304 fail:
11305 {
11306 if (temp2)
11307 delete arg2;
11308 }
11309 return NULL;
11310 }
11311
11312
11313 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11314 PyObject *resultobj = 0;
11315 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11316 wxString result;
11317 void *argp1 = 0 ;
11318 int res1 = 0 ;
11319 PyObject *swig_obj[1] ;
11320
11321 if (!args) SWIG_fail;
11322 swig_obj[0] = args;
11323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11324 if (!SWIG_IsOK(res1)) {
11325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11326 }
11327 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11328 {
11329 PyThreadState* __tstate = wxPyBeginAllowThreads();
11330 result = (arg1)->FindNext();
11331 wxPyEndAllowThreads(__tstate);
11332 if (PyErr_Occurred()) SWIG_fail;
11333 }
11334 {
11335 #if wxUSE_UNICODE
11336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11337 #else
11338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11339 #endif
11340 }
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11348 PyObject *obj;
11349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11350 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11351 return SWIG_Py_Void();
11352 }
11353
11354 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11355 return SWIG_Python_InitShadowInstance(args);
11356 }
11357
11358 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj = 0;
11360 wxString *arg1 = 0 ;
11361 wxImage *arg2 = 0 ;
11362 long arg3 ;
11363 bool temp1 = false ;
11364 void *argp2 = 0 ;
11365 int res2 = 0 ;
11366 long val3 ;
11367 int ecode3 = 0 ;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 char * kwnames[] = {
11372 (char *) "filename",(char *) "image",(char *) "type", NULL
11373 };
11374
11375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11376 {
11377 arg1 = wxString_in_helper(obj0);
11378 if (arg1 == NULL) SWIG_fail;
11379 temp1 = true;
11380 }
11381 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11382 if (!SWIG_IsOK(res2)) {
11383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11384 }
11385 if (!argp2) {
11386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11387 }
11388 arg2 = reinterpret_cast< wxImage * >(argp2);
11389 ecode3 = SWIG_AsVal_long(obj2, &val3);
11390 if (!SWIG_IsOK(ecode3)) {
11391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11392 }
11393 arg3 = static_cast< long >(val3);
11394 {
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 resultobj = SWIG_Py_Void();
11401 {
11402 if (temp1)
11403 delete arg1;
11404 }
11405 return resultobj;
11406 fail:
11407 {
11408 if (temp1)
11409 delete arg1;
11410 }
11411 return NULL;
11412 }
11413
11414
11415 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj = 0;
11417 wxString *arg1 = 0 ;
11418 wxBitmap *arg2 = 0 ;
11419 long arg3 ;
11420 bool temp1 = false ;
11421 void *argp2 = 0 ;
11422 int res2 = 0 ;
11423 long val3 ;
11424 int ecode3 = 0 ;
11425 PyObject * obj0 = 0 ;
11426 PyObject * obj1 = 0 ;
11427 PyObject * obj2 = 0 ;
11428 char * kwnames[] = {
11429 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11430 };
11431
11432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11433 {
11434 arg1 = wxString_in_helper(obj0);
11435 if (arg1 == NULL) SWIG_fail;
11436 temp1 = true;
11437 }
11438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11439 if (!SWIG_IsOK(res2)) {
11440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11441 }
11442 if (!argp2) {
11443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11444 }
11445 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11446 ecode3 = SWIG_AsVal_long(obj2, &val3);
11447 if (!SWIG_IsOK(ecode3)) {
11448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11449 }
11450 arg3 = static_cast< long >(val3);
11451 {
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 resultobj = SWIG_Py_Void();
11458 {
11459 if (temp1)
11460 delete arg1;
11461 }
11462 return resultobj;
11463 fail:
11464 {
11465 if (temp1)
11466 delete arg1;
11467 }
11468 return NULL;
11469 }
11470
11471
11472 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj = 0;
11474 wxString *arg1 = 0 ;
11475 PyObject *arg2 = (PyObject *) 0 ;
11476 bool temp1 = false ;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 char * kwnames[] = {
11480 (char *) "filename",(char *) "data", NULL
11481 };
11482
11483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11484 {
11485 arg1 = wxString_in_helper(obj0);
11486 if (arg1 == NULL) SWIG_fail;
11487 temp1 = true;
11488 }
11489 arg2 = obj1;
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 resultobj = SWIG_Py_Void();
11497 {
11498 if (temp1)
11499 delete arg1;
11500 }
11501 return resultobj;
11502 fail:
11503 {
11504 if (temp1)
11505 delete arg1;
11506 }
11507 return NULL;
11508 }
11509
11510
11511 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11512 PyObject *resultobj = 0;
11513 wxMemoryFSHandler *result = 0 ;
11514
11515 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxString *arg1 = 0 ;
11532 bool temp1 = false ;
11533 PyObject * obj0 = 0 ;
11534 char * kwnames[] = {
11535 (char *) "filename", NULL
11536 };
11537
11538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11539 {
11540 arg1 = wxString_in_helper(obj0);
11541 if (arg1 == NULL) SWIG_fail;
11542 temp1 = true;
11543 }
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11547 wxPyEndAllowThreads(__tstate);
11548 if (PyErr_Occurred()) SWIG_fail;
11549 }
11550 resultobj = SWIG_Py_Void();
11551 {
11552 if (temp1)
11553 delete arg1;
11554 }
11555 return resultobj;
11556 fail:
11557 {
11558 if (temp1)
11559 delete arg1;
11560 }
11561 return NULL;
11562 }
11563
11564
11565 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj = 0;
11567 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11568 wxString *arg2 = 0 ;
11569 bool result;
11570 void *argp1 = 0 ;
11571 int res1 = 0 ;
11572 bool temp2 = false ;
11573 PyObject * obj0 = 0 ;
11574 PyObject * obj1 = 0 ;
11575 char * kwnames[] = {
11576 (char *) "self",(char *) "location", NULL
11577 };
11578
11579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11581 if (!SWIG_IsOK(res1)) {
11582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11583 }
11584 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11585 {
11586 arg2 = wxString_in_helper(obj1);
11587 if (arg2 == NULL) SWIG_fail;
11588 temp2 = true;
11589 }
11590 {
11591 PyThreadState* __tstate = wxPyBeginAllowThreads();
11592 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 {
11597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11598 }
11599 {
11600 if (temp2)
11601 delete arg2;
11602 }
11603 return resultobj;
11604 fail:
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 return NULL;
11610 }
11611
11612
11613 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11614 PyObject *resultobj = 0;
11615 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11616 wxFileSystem *arg2 = 0 ;
11617 wxString *arg3 = 0 ;
11618 wxFSFile *result = 0 ;
11619 void *argp1 = 0 ;
11620 int res1 = 0 ;
11621 void *argp2 = 0 ;
11622 int res2 = 0 ;
11623 bool temp3 = false ;
11624 PyObject * obj0 = 0 ;
11625 PyObject * obj1 = 0 ;
11626 PyObject * obj2 = 0 ;
11627 char * kwnames[] = {
11628 (char *) "self",(char *) "fs",(char *) "location", NULL
11629 };
11630
11631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11635 }
11636 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11637 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11638 if (!SWIG_IsOK(res2)) {
11639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11640 }
11641 if (!argp2) {
11642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11643 }
11644 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11645 {
11646 arg3 = wxString_in_helper(obj2);
11647 if (arg3 == NULL) SWIG_fail;
11648 temp3 = true;
11649 }
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11658 }
11659 {
11660 if (temp3)
11661 delete arg3;
11662 }
11663 return resultobj;
11664 fail:
11665 {
11666 if (temp3)
11667 delete arg3;
11668 }
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj = 0;
11675 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11676 wxString *arg2 = 0 ;
11677 int arg3 = (int) 0 ;
11678 wxString result;
11679 void *argp1 = 0 ;
11680 int res1 = 0 ;
11681 bool temp2 = false ;
11682 int val3 ;
11683 int ecode3 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 PyObject * obj2 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "spec",(char *) "flags", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11695 }
11696 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11697 {
11698 arg2 = wxString_in_helper(obj1);
11699 if (arg2 == NULL) SWIG_fail;
11700 temp2 = true;
11701 }
11702 if (obj2) {
11703 ecode3 = SWIG_AsVal_int(obj2, &val3);
11704 if (!SWIG_IsOK(ecode3)) {
11705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11706 }
11707 arg3 = static_cast< int >(val3);
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 #if wxUSE_UNICODE
11717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11718 #else
11719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11720 #endif
11721 }
11722 {
11723 if (temp2)
11724 delete arg2;
11725 }
11726 return resultobj;
11727 fail:
11728 {
11729 if (temp2)
11730 delete arg2;
11731 }
11732 return NULL;
11733 }
11734
11735
11736 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737 PyObject *resultobj = 0;
11738 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11739 wxString result;
11740 void *argp1 = 0 ;
11741 int res1 = 0 ;
11742 PyObject *swig_obj[1] ;
11743
11744 if (!args) SWIG_fail;
11745 swig_obj[0] = args;
11746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11747 if (!SWIG_IsOK(res1)) {
11748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11749 }
11750 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11751 {
11752 PyThreadState* __tstate = wxPyBeginAllowThreads();
11753 result = (arg1)->FindNext();
11754 wxPyEndAllowThreads(__tstate);
11755 if (PyErr_Occurred()) SWIG_fail;
11756 }
11757 {
11758 #if wxUSE_UNICODE
11759 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11760 #else
11761 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11762 #endif
11763 }
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11771 PyObject *obj;
11772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11773 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11774 return SWIG_Py_Void();
11775 }
11776
11777 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11778 return SWIG_Python_InitShadowInstance(args);
11779 }
11780
11781 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11782 PyObject *resultobj = 0;
11783 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11784 wxString result;
11785 void *argp1 = 0 ;
11786 int res1 = 0 ;
11787 PyObject *swig_obj[1] ;
11788
11789 if (!args) SWIG_fail;
11790 swig_obj[0] = args;
11791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11792 if (!SWIG_IsOK(res1)) {
11793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11794 }
11795 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 result = (arg1)->GetName();
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 {
11803 #if wxUSE_UNICODE
11804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11805 #else
11806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11807 #endif
11808 }
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11816 PyObject *resultobj = 0;
11817 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11818 wxString result;
11819 void *argp1 = 0 ;
11820 int res1 = 0 ;
11821 PyObject *swig_obj[1] ;
11822
11823 if (!args) SWIG_fail;
11824 swig_obj[0] = args;
11825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11826 if (!SWIG_IsOK(res1)) {
11827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11828 }
11829 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 result = (arg1)->GetExtension();
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 {
11837 #if wxUSE_UNICODE
11838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11839 #else
11840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11841 #endif
11842 }
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11852 long result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11862 }
11863 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (long)(arg1)->GetType();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 resultobj = SWIG_From_long(static_cast< long >(result));
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 PyObject *resultobj = 0;
11879 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11880 wxString result;
11881 void *argp1 = 0 ;
11882 int res1 = 0 ;
11883 PyObject *swig_obj[1] ;
11884
11885 if (!args) SWIG_fail;
11886 swig_obj[0] = args;
11887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11888 if (!SWIG_IsOK(res1)) {
11889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11890 }
11891 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 result = (arg1)->GetMimeType();
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 {
11899 #if wxUSE_UNICODE
11900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11901 #else
11902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11903 #endif
11904 }
11905 return resultobj;
11906 fail:
11907 return NULL;
11908 }
11909
11910
11911 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11912 PyObject *resultobj = 0;
11913 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11914 wxString *arg2 = 0 ;
11915 bool result;
11916 void *argp1 = 0 ;
11917 int res1 = 0 ;
11918 bool temp2 = false ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 char * kwnames[] = {
11922 (char *) "self",(char *) "name", NULL
11923 };
11924
11925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11927 if (!SWIG_IsOK(res1)) {
11928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11929 }
11930 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11931 {
11932 arg2 = wxString_in_helper(obj1);
11933 if (arg2 == NULL) SWIG_fail;
11934 temp2 = true;
11935 }
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 {
11946 if (temp2)
11947 delete arg2;
11948 }
11949 return resultobj;
11950 fail:
11951 {
11952 if (temp2)
11953 delete arg2;
11954 }
11955 return NULL;
11956 }
11957
11958
11959 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11960 PyObject *resultobj = 0;
11961 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11962 wxInputStream *arg2 = 0 ;
11963 bool result;
11964 void *argp1 = 0 ;
11965 int res1 = 0 ;
11966 wxPyInputStream *temp2 ;
11967 bool created2 ;
11968 PyObject * obj0 = 0 ;
11969 PyObject * obj1 = 0 ;
11970 char * kwnames[] = {
11971 (char *) "self",(char *) "stream", NULL
11972 };
11973
11974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11976 if (!SWIG_IsOK(res1)) {
11977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11978 }
11979 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11980 {
11981 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11982 arg2 = temp2->m_wxis;
11983 created2 = false;
11984 } else {
11985 PyErr_Clear(); // clear the failure of the wxPyConvert above
11986 arg2 = wxPyCBInputStream_create(obj1, false);
11987 if (arg2 == NULL) {
11988 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11989 SWIG_fail;
11990 }
11991 created2 = true;
11992 }
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (bool)(arg1)->CanRead(*arg2);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12002 }
12003 {
12004 if (created2) delete arg2;
12005 }
12006 return resultobj;
12007 fail:
12008 {
12009 if (created2) delete arg2;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj = 0;
12017 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12018 wxString *arg2 = 0 ;
12019 void *argp1 = 0 ;
12020 int res1 = 0 ;
12021 bool temp2 = false ;
12022 PyObject * obj0 = 0 ;
12023 PyObject * obj1 = 0 ;
12024 char * kwnames[] = {
12025 (char *) "self",(char *) "name", NULL
12026 };
12027
12028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12030 if (!SWIG_IsOK(res1)) {
12031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12032 }
12033 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12034 {
12035 arg2 = wxString_in_helper(obj1);
12036 if (arg2 == NULL) SWIG_fail;
12037 temp2 = true;
12038 }
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 (arg1)->SetName((wxString const &)*arg2);
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 resultobj = SWIG_Py_Void();
12046 {
12047 if (temp2)
12048 delete arg2;
12049 }
12050 return resultobj;
12051 fail:
12052 {
12053 if (temp2)
12054 delete arg2;
12055 }
12056 return NULL;
12057 }
12058
12059
12060 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12061 PyObject *resultobj = 0;
12062 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12063 wxString *arg2 = 0 ;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 bool temp2 = false ;
12067 PyObject * obj0 = 0 ;
12068 PyObject * obj1 = 0 ;
12069 char * kwnames[] = {
12070 (char *) "self",(char *) "extension", NULL
12071 };
12072
12073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12075 if (!SWIG_IsOK(res1)) {
12076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12077 }
12078 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12079 {
12080 arg2 = wxString_in_helper(obj1);
12081 if (arg2 == NULL) SWIG_fail;
12082 temp2 = true;
12083 }
12084 {
12085 PyThreadState* __tstate = wxPyBeginAllowThreads();
12086 (arg1)->SetExtension((wxString const &)*arg2);
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 resultobj = SWIG_Py_Void();
12091 {
12092 if (temp2)
12093 delete arg2;
12094 }
12095 return resultobj;
12096 fail:
12097 {
12098 if (temp2)
12099 delete arg2;
12100 }
12101 return NULL;
12102 }
12103
12104
12105 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj = 0;
12107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12108 long arg2 ;
12109 void *argp1 = 0 ;
12110 int res1 = 0 ;
12111 long val2 ;
12112 int ecode2 = 0 ;
12113 PyObject * obj0 = 0 ;
12114 PyObject * obj1 = 0 ;
12115 char * kwnames[] = {
12116 (char *) "self",(char *) "type", NULL
12117 };
12118
12119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12121 if (!SWIG_IsOK(res1)) {
12122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12123 }
12124 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12125 ecode2 = SWIG_AsVal_long(obj1, &val2);
12126 if (!SWIG_IsOK(ecode2)) {
12127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12128 }
12129 arg2 = static_cast< long >(val2);
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 (arg1)->SetType(arg2);
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 resultobj = SWIG_Py_Void();
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12144 PyObject *resultobj = 0;
12145 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12146 wxString *arg2 = 0 ;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 bool temp2 = false ;
12150 PyObject * obj0 = 0 ;
12151 PyObject * obj1 = 0 ;
12152 char * kwnames[] = {
12153 (char *) "self",(char *) "mimetype", NULL
12154 };
12155
12156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12158 if (!SWIG_IsOK(res1)) {
12159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12160 }
12161 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12162 {
12163 arg2 = wxString_in_helper(obj1);
12164 if (arg2 == NULL) SWIG_fail;
12165 temp2 = true;
12166 }
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 (arg1)->SetMimeType((wxString const &)*arg2);
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 resultobj = SWIG_Py_Void();
12174 {
12175 if (temp2)
12176 delete arg2;
12177 }
12178 return resultobj;
12179 fail:
12180 {
12181 if (temp2)
12182 delete arg2;
12183 }
12184 return NULL;
12185 }
12186
12187
12188 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12189 PyObject *obj;
12190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12191 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12192 return SWIG_Py_Void();
12193 }
12194
12195 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12196 PyObject *resultobj = 0;
12197 wxPyImageHandler *result = 0 ;
12198
12199 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12200 {
12201 PyThreadState* __tstate = wxPyBeginAllowThreads();
12202 result = (wxPyImageHandler *)new wxPyImageHandler();
12203 wxPyEndAllowThreads(__tstate);
12204 if (PyErr_Occurred()) SWIG_fail;
12205 }
12206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12207 return resultobj;
12208 fail:
12209 return NULL;
12210 }
12211
12212
12213 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12214 PyObject *resultobj = 0;
12215 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12216 PyObject *arg2 = (PyObject *) 0 ;
12217 void *argp1 = 0 ;
12218 int res1 = 0 ;
12219 PyObject * obj0 = 0 ;
12220 PyObject * obj1 = 0 ;
12221 char * kwnames[] = {
12222 (char *) "self",(char *) "self", NULL
12223 };
12224
12225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12227 if (!SWIG_IsOK(res1)) {
12228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12229 }
12230 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12231 arg2 = obj1;
12232 {
12233 PyThreadState* __tstate = wxPyBeginAllowThreads();
12234 (arg1)->_SetSelf(arg2);
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 resultobj = SWIG_Py_Void();
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12246 PyObject *obj;
12247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12248 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12249 return SWIG_Py_Void();
12250 }
12251
12252 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12253 return SWIG_Python_InitShadowInstance(args);
12254 }
12255
12256 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12257 PyObject *resultobj = 0;
12258 wxImageHistogram *result = 0 ;
12259
12260 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 result = (wxImageHistogram *)new wxImageHistogram();
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj = 0;
12276 byte arg1 ;
12277 byte arg2 ;
12278 byte arg3 ;
12279 unsigned long result;
12280 unsigned char val1 ;
12281 int ecode1 = 0 ;
12282 unsigned char val2 ;
12283 int ecode2 = 0 ;
12284 unsigned char val3 ;
12285 int ecode3 = 0 ;
12286 PyObject * obj0 = 0 ;
12287 PyObject * obj1 = 0 ;
12288 PyObject * obj2 = 0 ;
12289 char * kwnames[] = {
12290 (char *) "r",(char *) "g",(char *) "b", NULL
12291 };
12292
12293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12294 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12295 if (!SWIG_IsOK(ecode1)) {
12296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12297 }
12298 arg1 = static_cast< byte >(val1);
12299 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12300 if (!SWIG_IsOK(ecode2)) {
12301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12302 }
12303 arg2 = static_cast< byte >(val2);
12304 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12305 if (!SWIG_IsOK(ecode3)) {
12306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12307 }
12308 arg3 = static_cast< byte >(val3);
12309 {
12310 PyThreadState* __tstate = wxPyBeginAllowThreads();
12311 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12316 return resultobj;
12317 fail:
12318 return NULL;
12319 }
12320
12321
12322 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj = 0;
12324 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12325 byte *arg2 = (byte *) 0 ;
12326 byte *arg3 = (byte *) 0 ;
12327 byte *arg4 = (byte *) 0 ;
12328 byte arg5 = (byte) 1 ;
12329 byte arg6 = (byte) 0 ;
12330 byte arg7 = (byte) 0 ;
12331 bool result;
12332 void *argp1 = 0 ;
12333 int res1 = 0 ;
12334 byte temp2 ;
12335 int res2 = SWIG_TMPOBJ ;
12336 byte temp3 ;
12337 int res3 = SWIG_TMPOBJ ;
12338 byte temp4 ;
12339 int res4 = SWIG_TMPOBJ ;
12340 unsigned char val5 ;
12341 int ecode5 = 0 ;
12342 unsigned char val6 ;
12343 int ecode6 = 0 ;
12344 unsigned char val7 ;
12345 int ecode7 = 0 ;
12346 PyObject * obj0 = 0 ;
12347 PyObject * obj1 = 0 ;
12348 PyObject * obj2 = 0 ;
12349 PyObject * obj3 = 0 ;
12350 char * kwnames[] = {
12351 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12352 };
12353
12354 arg2 = &temp2;
12355 arg3 = &temp3;
12356 arg4 = &temp4;
12357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12359 if (!SWIG_IsOK(res1)) {
12360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12361 }
12362 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12363 if (obj1) {
12364 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12365 if (!SWIG_IsOK(ecode5)) {
12366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12367 }
12368 arg5 = static_cast< byte >(val5);
12369 }
12370 if (obj2) {
12371 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12372 if (!SWIG_IsOK(ecode6)) {
12373 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12374 }
12375 arg6 = static_cast< byte >(val6);
12376 }
12377 if (obj3) {
12378 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12379 if (!SWIG_IsOK(ecode7)) {
12380 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12381 }
12382 arg7 = static_cast< byte >(val7);
12383 }
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 {
12391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12392 }
12393 if (SWIG_IsTmpObj(res2)) {
12394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12395 } else {
12396 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12398 }
12399 if (SWIG_IsTmpObj(res3)) {
12400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12401 } else {
12402 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12404 }
12405 if (SWIG_IsTmpObj(res4)) {
12406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12407 } else {
12408 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12410 }
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12418 PyObject *resultobj = 0;
12419 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12420 unsigned long arg2 ;
12421 unsigned long result;
12422 void *argp1 = 0 ;
12423 int res1 = 0 ;
12424 unsigned long val2 ;
12425 int ecode2 = 0 ;
12426 PyObject * obj0 = 0 ;
12427 PyObject * obj1 = 0 ;
12428 char * kwnames[] = {
12429 (char *) "self",(char *) "key", NULL
12430 };
12431
12432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12434 if (!SWIG_IsOK(res1)) {
12435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12436 }
12437 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12438 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12439 if (!SWIG_IsOK(ecode2)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12441 }
12442 arg2 = static_cast< unsigned long >(val2);
12443 {
12444 PyThreadState* __tstate = wxPyBeginAllowThreads();
12445 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj = 0;
12458 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12459 byte arg2 ;
12460 byte arg3 ;
12461 byte arg4 ;
12462 unsigned long result;
12463 void *argp1 = 0 ;
12464 int res1 = 0 ;
12465 unsigned char val2 ;
12466 int ecode2 = 0 ;
12467 unsigned char val3 ;
12468 int ecode3 = 0 ;
12469 unsigned char val4 ;
12470 int ecode4 = 0 ;
12471 PyObject * obj0 = 0 ;
12472 PyObject * obj1 = 0 ;
12473 PyObject * obj2 = 0 ;
12474 PyObject * obj3 = 0 ;
12475 char * kwnames[] = {
12476 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12477 };
12478
12479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12481 if (!SWIG_IsOK(res1)) {
12482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12483 }
12484 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12485 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12486 if (!SWIG_IsOK(ecode2)) {
12487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12488 }
12489 arg2 = static_cast< byte >(val2);
12490 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12491 if (!SWIG_IsOK(ecode3)) {
12492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12493 }
12494 arg3 = static_cast< byte >(val3);
12495 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12496 if (!SWIG_IsOK(ecode4)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12498 }
12499 arg4 = static_cast< byte >(val4);
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = 0;
12515 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12516 wxColour *arg2 = 0 ;
12517 unsigned long result;
12518 void *argp1 = 0 ;
12519 int res1 = 0 ;
12520 wxColour temp2 ;
12521 PyObject * obj0 = 0 ;
12522 PyObject * obj1 = 0 ;
12523 char * kwnames[] = {
12524 (char *) "self",(char *) "colour", NULL
12525 };
12526
12527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12529 if (!SWIG_IsOK(res1)) {
12530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12531 }
12532 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12533 {
12534 arg2 = &temp2;
12535 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12536 }
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12551 PyObject *obj;
12552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12553 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12554 return SWIG_Py_Void();
12555 }
12556
12557 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12558 return SWIG_Python_InitShadowInstance(args);
12559 }
12560
12561 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12562 PyObject *resultobj = 0;
12563 byte arg1 = (byte) 0 ;
12564 byte arg2 = (byte) 0 ;
12565 byte arg3 = (byte) 0 ;
12566 wxImage_RGBValue *result = 0 ;
12567 unsigned char val1 ;
12568 int ecode1 = 0 ;
12569 unsigned char val2 ;
12570 int ecode2 = 0 ;
12571 unsigned char val3 ;
12572 int ecode3 = 0 ;
12573 PyObject * obj0 = 0 ;
12574 PyObject * obj1 = 0 ;
12575 PyObject * obj2 = 0 ;
12576 char * kwnames[] = {
12577 (char *) "r",(char *) "g",(char *) "b", NULL
12578 };
12579
12580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12581 if (obj0) {
12582 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12583 if (!SWIG_IsOK(ecode1)) {
12584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12585 }
12586 arg1 = static_cast< byte >(val1);
12587 }
12588 if (obj1) {
12589 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12590 if (!SWIG_IsOK(ecode2)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12592 }
12593 arg2 = static_cast< byte >(val2);
12594 }
12595 if (obj2) {
12596 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12597 if (!SWIG_IsOK(ecode3)) {
12598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12599 }
12600 arg3 = static_cast< byte >(val3);
12601 }
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12605 wxPyEndAllowThreads(__tstate);
12606 if (PyErr_Occurred()) SWIG_fail;
12607 }
12608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12616 PyObject *resultobj = 0;
12617 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12618 byte arg2 ;
12619 void *argp1 = 0 ;
12620 int res1 = 0 ;
12621 unsigned char val2 ;
12622 int ecode2 = 0 ;
12623 PyObject *swig_obj[2] ;
12624
12625 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12627 if (!SWIG_IsOK(res1)) {
12628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12629 }
12630 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12631 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12632 if (!SWIG_IsOK(ecode2)) {
12633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12634 }
12635 arg2 = static_cast< byte >(val2);
12636 if (arg1) (arg1)->red = arg2;
12637
12638 resultobj = SWIG_Py_Void();
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12646 PyObject *resultobj = 0;
12647 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12648 byte result;
12649 void *argp1 = 0 ;
12650 int res1 = 0 ;
12651 PyObject *swig_obj[1] ;
12652
12653 if (!args) SWIG_fail;
12654 swig_obj[0] = args;
12655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12656 if (!SWIG_IsOK(res1)) {
12657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12658 }
12659 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12660 result = (byte) ((arg1)->red);
12661 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12662 return resultobj;
12663 fail:
12664 return NULL;
12665 }
12666
12667
12668 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12669 PyObject *resultobj = 0;
12670 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12671 byte arg2 ;
12672 void *argp1 = 0 ;
12673 int res1 = 0 ;
12674 unsigned char val2 ;
12675 int ecode2 = 0 ;
12676 PyObject *swig_obj[2] ;
12677
12678 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12680 if (!SWIG_IsOK(res1)) {
12681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12682 }
12683 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12684 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12685 if (!SWIG_IsOK(ecode2)) {
12686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12687 }
12688 arg2 = static_cast< byte >(val2);
12689 if (arg1) (arg1)->green = arg2;
12690
12691 resultobj = SWIG_Py_Void();
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12699 PyObject *resultobj = 0;
12700 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12701 byte result;
12702 void *argp1 = 0 ;
12703 int res1 = 0 ;
12704 PyObject *swig_obj[1] ;
12705
12706 if (!args) SWIG_fail;
12707 swig_obj[0] = args;
12708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12711 }
12712 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12713 result = (byte) ((arg1)->green);
12714 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12722 PyObject *resultobj = 0;
12723 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12724 byte arg2 ;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 unsigned char val2 ;
12728 int ecode2 = 0 ;
12729 PyObject *swig_obj[2] ;
12730
12731 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12733 if (!SWIG_IsOK(res1)) {
12734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12735 }
12736 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12737 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12738 if (!SWIG_IsOK(ecode2)) {
12739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12740 }
12741 arg2 = static_cast< byte >(val2);
12742 if (arg1) (arg1)->blue = arg2;
12743
12744 resultobj = SWIG_Py_Void();
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12754 byte result;
12755 void *argp1 = 0 ;
12756 int res1 = 0 ;
12757 PyObject *swig_obj[1] ;
12758
12759 if (!args) SWIG_fail;
12760 swig_obj[0] = args;
12761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12762 if (!SWIG_IsOK(res1)) {
12763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12764 }
12765 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12766 result = (byte) ((arg1)->blue);
12767 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12775 PyObject *obj;
12776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12777 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12778 return SWIG_Py_Void();
12779 }
12780
12781 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12782 return SWIG_Python_InitShadowInstance(args);
12783 }
12784
12785 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12786 PyObject *resultobj = 0;
12787 double arg1 = (double) 0.0 ;
12788 double arg2 = (double) 0.0 ;
12789 double arg3 = (double) 0.0 ;
12790 wxImage_HSVValue *result = 0 ;
12791 double val1 ;
12792 int ecode1 = 0 ;
12793 double val2 ;
12794 int ecode2 = 0 ;
12795 double val3 ;
12796 int ecode3 = 0 ;
12797 PyObject * obj0 = 0 ;
12798 PyObject * obj1 = 0 ;
12799 PyObject * obj2 = 0 ;
12800 char * kwnames[] = {
12801 (char *) "h",(char *) "s",(char *) "v", NULL
12802 };
12803
12804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12805 if (obj0) {
12806 ecode1 = SWIG_AsVal_double(obj0, &val1);
12807 if (!SWIG_IsOK(ecode1)) {
12808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12809 }
12810 arg1 = static_cast< double >(val1);
12811 }
12812 if (obj1) {
12813 ecode2 = SWIG_AsVal_double(obj1, &val2);
12814 if (!SWIG_IsOK(ecode2)) {
12815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12816 }
12817 arg2 = static_cast< double >(val2);
12818 }
12819 if (obj2) {
12820 ecode3 = SWIG_AsVal_double(obj2, &val3);
12821 if (!SWIG_IsOK(ecode3)) {
12822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12823 }
12824 arg3 = static_cast< double >(val3);
12825 }
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 PyObject *resultobj = 0;
12841 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12842 double arg2 ;
12843 void *argp1 = 0 ;
12844 int res1 = 0 ;
12845 double val2 ;
12846 int ecode2 = 0 ;
12847 PyObject *swig_obj[2] ;
12848
12849 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12851 if (!SWIG_IsOK(res1)) {
12852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12853 }
12854 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12855 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12856 if (!SWIG_IsOK(ecode2)) {
12857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12858 }
12859 arg2 = static_cast< double >(val2);
12860 if (arg1) (arg1)->hue = arg2;
12861
12862 resultobj = SWIG_Py_Void();
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12870 PyObject *resultobj = 0;
12871 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12872 double result;
12873 void *argp1 = 0 ;
12874 int res1 = 0 ;
12875 PyObject *swig_obj[1] ;
12876
12877 if (!args) SWIG_fail;
12878 swig_obj[0] = args;
12879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12882 }
12883 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12884 result = (double) ((arg1)->hue);
12885 resultobj = SWIG_From_double(static_cast< double >(result));
12886 return resultobj;
12887 fail:
12888 return NULL;
12889 }
12890
12891
12892 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12893 PyObject *resultobj = 0;
12894 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12895 double arg2 ;
12896 void *argp1 = 0 ;
12897 int res1 = 0 ;
12898 double val2 ;
12899 int ecode2 = 0 ;
12900 PyObject *swig_obj[2] ;
12901
12902 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12904 if (!SWIG_IsOK(res1)) {
12905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12906 }
12907 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12908 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12909 if (!SWIG_IsOK(ecode2)) {
12910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12911 }
12912 arg2 = static_cast< double >(val2);
12913 if (arg1) (arg1)->saturation = arg2;
12914
12915 resultobj = SWIG_Py_Void();
12916 return resultobj;
12917 fail:
12918 return NULL;
12919 }
12920
12921
12922 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12923 PyObject *resultobj = 0;
12924 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12925 double result;
12926 void *argp1 = 0 ;
12927 int res1 = 0 ;
12928 PyObject *swig_obj[1] ;
12929
12930 if (!args) SWIG_fail;
12931 swig_obj[0] = args;
12932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12933 if (!SWIG_IsOK(res1)) {
12934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12935 }
12936 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12937 result = (double) ((arg1)->saturation);
12938 resultobj = SWIG_From_double(static_cast< double >(result));
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12946 PyObject *resultobj = 0;
12947 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12948 double arg2 ;
12949 void *argp1 = 0 ;
12950 int res1 = 0 ;
12951 double val2 ;
12952 int ecode2 = 0 ;
12953 PyObject *swig_obj[2] ;
12954
12955 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12957 if (!SWIG_IsOK(res1)) {
12958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12959 }
12960 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12961 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12962 if (!SWIG_IsOK(ecode2)) {
12963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12964 }
12965 arg2 = static_cast< double >(val2);
12966 if (arg1) (arg1)->value = arg2;
12967
12968 resultobj = SWIG_Py_Void();
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976 PyObject *resultobj = 0;
12977 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12978 double result;
12979 void *argp1 = 0 ;
12980 int res1 = 0 ;
12981 PyObject *swig_obj[1] ;
12982
12983 if (!args) SWIG_fail;
12984 swig_obj[0] = args;
12985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12986 if (!SWIG_IsOK(res1)) {
12987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12988 }
12989 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12990 result = (double) ((arg1)->value);
12991 resultobj = SWIG_From_double(static_cast< double >(result));
12992 return resultobj;
12993 fail:
12994 return NULL;
12995 }
12996
12997
12998 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12999 PyObject *obj;
13000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13001 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13002 return SWIG_Py_Void();
13003 }
13004
13005 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13006 return SWIG_Python_InitShadowInstance(args);
13007 }
13008
13009 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj = 0;
13011 wxString *arg1 = 0 ;
13012 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13013 int arg3 = (int) -1 ;
13014 wxImage *result = 0 ;
13015 bool temp1 = false ;
13016 long val2 ;
13017 int ecode2 = 0 ;
13018 int val3 ;
13019 int ecode3 = 0 ;
13020 PyObject * obj0 = 0 ;
13021 PyObject * obj1 = 0 ;
13022 PyObject * obj2 = 0 ;
13023 char * kwnames[] = {
13024 (char *) "name",(char *) "type",(char *) "index", NULL
13025 };
13026
13027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13028 {
13029 arg1 = wxString_in_helper(obj0);
13030 if (arg1 == NULL) SWIG_fail;
13031 temp1 = true;
13032 }
13033 if (obj1) {
13034 ecode2 = SWIG_AsVal_long(obj1, &val2);
13035 if (!SWIG_IsOK(ecode2)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13037 }
13038 arg2 = static_cast< long >(val2);
13039 }
13040 if (obj2) {
13041 ecode3 = SWIG_AsVal_int(obj2, &val3);
13042 if (!SWIG_IsOK(ecode3)) {
13043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13044 }
13045 arg3 = static_cast< int >(val3);
13046 }
13047 {
13048 PyThreadState* __tstate = wxPyBeginAllowThreads();
13049 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13054 {
13055 if (temp1)
13056 delete arg1;
13057 }
13058 return resultobj;
13059 fail:
13060 {
13061 if (temp1)
13062 delete arg1;
13063 }
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13069 PyObject *resultobj = 0;
13070 wxImage *arg1 = (wxImage *) 0 ;
13071 void *argp1 = 0 ;
13072 int res1 = 0 ;
13073 PyObject *swig_obj[1] ;
13074
13075 if (!args) SWIG_fail;
13076 swig_obj[0] = args;
13077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13078 if (!SWIG_IsOK(res1)) {
13079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13080 }
13081 arg1 = reinterpret_cast< wxImage * >(argp1);
13082 {
13083 PyThreadState* __tstate = wxPyBeginAllowThreads();
13084 delete arg1;
13085
13086 wxPyEndAllowThreads(__tstate);
13087 if (PyErr_Occurred()) SWIG_fail;
13088 }
13089 resultobj = SWIG_Py_Void();
13090 return resultobj;
13091 fail:
13092 return NULL;
13093 }
13094
13095
13096 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13097 PyObject *resultobj = 0;
13098 wxString *arg1 = 0 ;
13099 wxString *arg2 = 0 ;
13100 int arg3 = (int) -1 ;
13101 wxImage *result = 0 ;
13102 bool temp1 = false ;
13103 bool temp2 = false ;
13104 int val3 ;
13105 int ecode3 = 0 ;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 PyObject * obj2 = 0 ;
13109 char * kwnames[] = {
13110 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13111 };
13112
13113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13114 {
13115 arg1 = wxString_in_helper(obj0);
13116 if (arg1 == NULL) SWIG_fail;
13117 temp1 = true;
13118 }
13119 {
13120 arg2 = wxString_in_helper(obj1);
13121 if (arg2 == NULL) SWIG_fail;
13122 temp2 = true;
13123 }
13124 if (obj2) {
13125 ecode3 = SWIG_AsVal_int(obj2, &val3);
13126 if (!SWIG_IsOK(ecode3)) {
13127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13128 }
13129 arg3 = static_cast< int >(val3);
13130 }
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13134 wxPyEndAllowThreads(__tstate);
13135 if (PyErr_Occurred()) SWIG_fail;
13136 }
13137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13138 {
13139 if (temp1)
13140 delete arg1;
13141 }
13142 {
13143 if (temp2)
13144 delete arg2;
13145 }
13146 return resultobj;
13147 fail:
13148 {
13149 if (temp1)
13150 delete arg1;
13151 }
13152 {
13153 if (temp2)
13154 delete arg2;
13155 }
13156 return NULL;
13157 }
13158
13159
13160 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13161 PyObject *resultobj = 0;
13162 wxInputStream *arg1 = 0 ;
13163 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13164 int arg3 = (int) -1 ;
13165 wxImage *result = 0 ;
13166 wxPyInputStream *temp1 ;
13167 bool created1 ;
13168 long val2 ;
13169 int ecode2 = 0 ;
13170 int val3 ;
13171 int ecode3 = 0 ;
13172 PyObject * obj0 = 0 ;
13173 PyObject * obj1 = 0 ;
13174 PyObject * obj2 = 0 ;
13175 char * kwnames[] = {
13176 (char *) "stream",(char *) "type",(char *) "index", NULL
13177 };
13178
13179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13180 {
13181 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13182 arg1 = temp1->m_wxis;
13183 created1 = false;
13184 } else {
13185 PyErr_Clear(); // clear the failure of the wxPyConvert above
13186 arg1 = wxPyCBInputStream_create(obj0, false);
13187 if (arg1 == NULL) {
13188 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13189 SWIG_fail;
13190 }
13191 created1 = true;
13192 }
13193 }
13194 if (obj1) {
13195 ecode2 = SWIG_AsVal_long(obj1, &val2);
13196 if (!SWIG_IsOK(ecode2)) {
13197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13198 }
13199 arg2 = static_cast< long >(val2);
13200 }
13201 if (obj2) {
13202 ecode3 = SWIG_AsVal_int(obj2, &val3);
13203 if (!SWIG_IsOK(ecode3)) {
13204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13205 }
13206 arg3 = static_cast< int >(val3);
13207 }
13208 {
13209 PyThreadState* __tstate = wxPyBeginAllowThreads();
13210 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13215 {
13216 if (created1) delete arg1;
13217 }
13218 return resultobj;
13219 fail:
13220 {
13221 if (created1) delete arg1;
13222 }
13223 return NULL;
13224 }
13225
13226
13227 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13228 PyObject *resultobj = 0;
13229 wxInputStream *arg1 = 0 ;
13230 wxString *arg2 = 0 ;
13231 int arg3 = (int) -1 ;
13232 wxImage *result = 0 ;
13233 wxPyInputStream *temp1 ;
13234 bool created1 ;
13235 bool temp2 = false ;
13236 int val3 ;
13237 int ecode3 = 0 ;
13238 PyObject * obj0 = 0 ;
13239 PyObject * obj1 = 0 ;
13240 PyObject * obj2 = 0 ;
13241 char * kwnames[] = {
13242 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13243 };
13244
13245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13246 {
13247 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13248 arg1 = temp1->m_wxis;
13249 created1 = false;
13250 } else {
13251 PyErr_Clear(); // clear the failure of the wxPyConvert above
13252 arg1 = wxPyCBInputStream_create(obj0, false);
13253 if (arg1 == NULL) {
13254 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13255 SWIG_fail;
13256 }
13257 created1 = true;
13258 }
13259 }
13260 {
13261 arg2 = wxString_in_helper(obj1);
13262 if (arg2 == NULL) SWIG_fail;
13263 temp2 = true;
13264 }
13265 if (obj2) {
13266 ecode3 = SWIG_AsVal_int(obj2, &val3);
13267 if (!SWIG_IsOK(ecode3)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13269 }
13270 arg3 = static_cast< int >(val3);
13271 }
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13279 {
13280 if (created1) delete arg1;
13281 }
13282 {
13283 if (temp2)
13284 delete arg2;
13285 }
13286 return resultobj;
13287 fail:
13288 {
13289 if (created1) delete arg1;
13290 }
13291 {
13292 if (temp2)
13293 delete arg2;
13294 }
13295 return NULL;
13296 }
13297
13298
13299 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13300 PyObject *resultobj = 0;
13301 int arg1 = (int) 0 ;
13302 int arg2 = (int) 0 ;
13303 bool arg3 = (bool) true ;
13304 wxImage *result = 0 ;
13305 int val1 ;
13306 int ecode1 = 0 ;
13307 int val2 ;
13308 int ecode2 = 0 ;
13309 bool val3 ;
13310 int ecode3 = 0 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char * kwnames[] = {
13315 (char *) "width",(char *) "height",(char *) "clear", NULL
13316 };
13317
13318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13319 if (obj0) {
13320 ecode1 = SWIG_AsVal_int(obj0, &val1);
13321 if (!SWIG_IsOK(ecode1)) {
13322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13323 }
13324 arg1 = static_cast< int >(val1);
13325 }
13326 if (obj1) {
13327 ecode2 = SWIG_AsVal_int(obj1, &val2);
13328 if (!SWIG_IsOK(ecode2)) {
13329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13330 }
13331 arg2 = static_cast< int >(val2);
13332 }
13333 if (obj2) {
13334 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13335 if (!SWIG_IsOK(ecode3)) {
13336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13337 }
13338 arg3 = static_cast< bool >(val3);
13339 }
13340 {
13341 PyThreadState* __tstate = wxPyBeginAllowThreads();
13342 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13343 wxPyEndAllowThreads(__tstate);
13344 if (PyErr_Occurred()) SWIG_fail;
13345 }
13346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13347 return resultobj;
13348 fail:
13349 return NULL;
13350 }
13351
13352
13353 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13354 PyObject *resultobj = 0;
13355 wxBitmap *arg1 = 0 ;
13356 wxImage *result = 0 ;
13357 void *argp1 = 0 ;
13358 int res1 = 0 ;
13359 PyObject * obj0 = 0 ;
13360 char * kwnames[] = {
13361 (char *) "bitmap", NULL
13362 };
13363
13364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13365 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13366 if (!SWIG_IsOK(res1)) {
13367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13368 }
13369 if (!argp1) {
13370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13371 }
13372 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13373 {
13374 if (!wxPyCheckForApp()) SWIG_fail;
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13388 PyObject *resultobj = 0;
13389 int arg1 ;
13390 int arg2 ;
13391 buffer arg3 ;
13392 int arg4 ;
13393 wxImage *result = 0 ;
13394 int val1 ;
13395 int ecode1 = 0 ;
13396 int val2 ;
13397 int ecode2 = 0 ;
13398 Py_ssize_t temp3 ;
13399 PyObject * obj0 = 0 ;
13400 PyObject * obj1 = 0 ;
13401 PyObject * obj2 = 0 ;
13402 char * kwnames[] = {
13403 (char *) "width",(char *) "height",(char *) "data", NULL
13404 };
13405
13406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13407 ecode1 = SWIG_AsVal_int(obj0, &val1);
13408 if (!SWIG_IsOK(ecode1)) {
13409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13410 }
13411 arg1 = static_cast< int >(val1);
13412 ecode2 = SWIG_AsVal_int(obj1, &val2);
13413 if (!SWIG_IsOK(ecode2)) {
13414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13415 }
13416 arg2 = static_cast< int >(val2);
13417 {
13418 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13419 arg4 = (int)temp3;
13420 }
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13428 return resultobj;
13429 fail:
13430 return NULL;
13431 }
13432
13433
13434 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13435 PyObject *resultobj = 0;
13436 int arg1 ;
13437 int arg2 ;
13438 buffer arg3 ;
13439 int arg4 ;
13440 buffer arg5 ;
13441 int arg6 ;
13442 wxImage *result = 0 ;
13443 int val1 ;
13444 int ecode1 = 0 ;
13445 int val2 ;
13446 int ecode2 = 0 ;
13447 Py_ssize_t temp3 ;
13448 Py_ssize_t temp5 ;
13449 PyObject * obj0 = 0 ;
13450 PyObject * obj1 = 0 ;
13451 PyObject * obj2 = 0 ;
13452 PyObject * obj3 = 0 ;
13453 char * kwnames[] = {
13454 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13455 };
13456
13457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13458 ecode1 = SWIG_AsVal_int(obj0, &val1);
13459 if (!SWIG_IsOK(ecode1)) {
13460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13461 }
13462 arg1 = static_cast< int >(val1);
13463 ecode2 = SWIG_AsVal_int(obj1, &val2);
13464 if (!SWIG_IsOK(ecode2)) {
13465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13466 }
13467 arg2 = static_cast< int >(val2);
13468 {
13469 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13470 arg4 = (int)temp3;
13471 }
13472 {
13473 if (obj3 != Py_None) {
13474 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13475 arg6 = (int)temp5;
13476 }
13477 }
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13485 return resultobj;
13486 fail:
13487 return NULL;
13488 }
13489
13490
13491 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13492 PyObject *resultobj = 0;
13493 wxImage *arg1 = (wxImage *) 0 ;
13494 int arg2 ;
13495 int arg3 ;
13496 bool arg4 = (bool) true ;
13497 void *argp1 = 0 ;
13498 int res1 = 0 ;
13499 int val2 ;
13500 int ecode2 = 0 ;
13501 int val3 ;
13502 int ecode3 = 0 ;
13503 bool val4 ;
13504 int ecode4 = 0 ;
13505 PyObject * obj0 = 0 ;
13506 PyObject * obj1 = 0 ;
13507 PyObject * obj2 = 0 ;
13508 PyObject * obj3 = 0 ;
13509 char * kwnames[] = {
13510 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13511 };
13512
13513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13515 if (!SWIG_IsOK(res1)) {
13516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13517 }
13518 arg1 = reinterpret_cast< wxImage * >(argp1);
13519 ecode2 = SWIG_AsVal_int(obj1, &val2);
13520 if (!SWIG_IsOK(ecode2)) {
13521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13522 }
13523 arg2 = static_cast< int >(val2);
13524 ecode3 = SWIG_AsVal_int(obj2, &val3);
13525 if (!SWIG_IsOK(ecode3)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13527 }
13528 arg3 = static_cast< int >(val3);
13529 if (obj3) {
13530 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13531 if (!SWIG_IsOK(ecode4)) {
13532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13533 }
13534 arg4 = static_cast< bool >(val4);
13535 }
13536 {
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 (arg1)->Create(arg2,arg3,arg4);
13539 wxPyEndAllowThreads(__tstate);
13540 if (PyErr_Occurred()) SWIG_fail;
13541 }
13542 resultobj = SWIG_Py_Void();
13543 return resultobj;
13544 fail:
13545 return NULL;
13546 }
13547
13548
13549 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13550 PyObject *resultobj = 0;
13551 wxImage *arg1 = (wxImage *) 0 ;
13552 void *argp1 = 0 ;
13553 int res1 = 0 ;
13554 PyObject *swig_obj[1] ;
13555
13556 if (!args) SWIG_fail;
13557 swig_obj[0] = args;
13558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13559 if (!SWIG_IsOK(res1)) {
13560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13561 }
13562 arg1 = reinterpret_cast< wxImage * >(argp1);
13563 {
13564 PyThreadState* __tstate = wxPyBeginAllowThreads();
13565 (arg1)->Destroy();
13566 wxPyEndAllowThreads(__tstate);
13567 if (PyErr_Occurred()) SWIG_fail;
13568 }
13569 resultobj = SWIG_Py_Void();
13570 return resultobj;
13571 fail:
13572 return NULL;
13573 }
13574
13575
13576 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13577 PyObject *resultobj = 0;
13578 wxImage *arg1 = (wxImage *) 0 ;
13579 int arg2 ;
13580 int arg3 ;
13581 SwigValueWrapper<wxImage > result;
13582 void *argp1 = 0 ;
13583 int res1 = 0 ;
13584 int val2 ;
13585 int ecode2 = 0 ;
13586 int val3 ;
13587 int ecode3 = 0 ;
13588 PyObject * obj0 = 0 ;
13589 PyObject * obj1 = 0 ;
13590 PyObject * obj2 = 0 ;
13591 char * kwnames[] = {
13592 (char *) "self",(char *) "width",(char *) "height", NULL
13593 };
13594
13595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13597 if (!SWIG_IsOK(res1)) {
13598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13599 }
13600 arg1 = reinterpret_cast< wxImage * >(argp1);
13601 ecode2 = SWIG_AsVal_int(obj1, &val2);
13602 if (!SWIG_IsOK(ecode2)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13604 }
13605 arg2 = static_cast< int >(val2);
13606 ecode3 = SWIG_AsVal_int(obj2, &val3);
13607 if (!SWIG_IsOK(ecode3)) {
13608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13609 }
13610 arg3 = static_cast< int >(val3);
13611 {
13612 PyThreadState* __tstate = wxPyBeginAllowThreads();
13613 result = (arg1)->Scale(arg2,arg3);
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 wxImage *arg1 = (wxImage *) 0 ;
13627 int arg2 ;
13628 int arg3 ;
13629 SwigValueWrapper<wxImage > result;
13630 void *argp1 = 0 ;
13631 int res1 = 0 ;
13632 int val2 ;
13633 int ecode2 = 0 ;
13634 int val3 ;
13635 int ecode3 = 0 ;
13636 PyObject * obj0 = 0 ;
13637 PyObject * obj1 = 0 ;
13638 PyObject * obj2 = 0 ;
13639 char * kwnames[] = {
13640 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13641 };
13642
13643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13645 if (!SWIG_IsOK(res1)) {
13646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13647 }
13648 arg1 = reinterpret_cast< wxImage * >(argp1);
13649 ecode2 = SWIG_AsVal_int(obj1, &val2);
13650 if (!SWIG_IsOK(ecode2)) {
13651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13652 }
13653 arg2 = static_cast< int >(val2);
13654 ecode3 = SWIG_AsVal_int(obj2, &val3);
13655 if (!SWIG_IsOK(ecode3)) {
13656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13657 }
13658 arg3 = static_cast< int >(val3);
13659 {
13660 PyThreadState* __tstate = wxPyBeginAllowThreads();
13661 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13666 return resultobj;
13667 fail:
13668 return NULL;
13669 }
13670
13671
13672 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13673 PyObject *resultobj = 0;
13674 wxImage *arg1 = (wxImage *) 0 ;
13675 int arg2 ;
13676 int arg3 ;
13677 wxImage *result = 0 ;
13678 void *argp1 = 0 ;
13679 int res1 = 0 ;
13680 int val2 ;
13681 int ecode2 = 0 ;
13682 int val3 ;
13683 int ecode3 = 0 ;
13684 PyObject * obj0 = 0 ;
13685 PyObject * obj1 = 0 ;
13686 PyObject * obj2 = 0 ;
13687 char * kwnames[] = {
13688 (char *) "self",(char *) "width",(char *) "height", NULL
13689 };
13690
13691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13693 if (!SWIG_IsOK(res1)) {
13694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13695 }
13696 arg1 = reinterpret_cast< wxImage * >(argp1);
13697 ecode2 = SWIG_AsVal_int(obj1, &val2);
13698 if (!SWIG_IsOK(ecode2)) {
13699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13700 }
13701 arg2 = static_cast< int >(val2);
13702 ecode3 = SWIG_AsVal_int(obj2, &val3);
13703 if (!SWIG_IsOK(ecode3)) {
13704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13705 }
13706 arg3 = static_cast< int >(val3);
13707 {
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 {
13710 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13711 result = (wxImage *) &_result_ref;
13712 }
13713 wxPyEndAllowThreads(__tstate);
13714 if (PyErr_Occurred()) SWIG_fail;
13715 }
13716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13717 return resultobj;
13718 fail:
13719 return NULL;
13720 }
13721
13722
13723 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13724 PyObject *resultobj = 0;
13725 wxImage *arg1 = (wxImage *) 0 ;
13726 wxSize *arg2 = 0 ;
13727 wxPoint *arg3 = 0 ;
13728 int arg4 = (int) -1 ;
13729 int arg5 = (int) -1 ;
13730 int arg6 = (int) -1 ;
13731 wxImage *result = 0 ;
13732 void *argp1 = 0 ;
13733 int res1 = 0 ;
13734 wxSize temp2 ;
13735 wxPoint temp3 ;
13736 int val4 ;
13737 int ecode4 = 0 ;
13738 int val5 ;
13739 int ecode5 = 0 ;
13740 int val6 ;
13741 int ecode6 = 0 ;
13742 PyObject * obj0 = 0 ;
13743 PyObject * obj1 = 0 ;
13744 PyObject * obj2 = 0 ;
13745 PyObject * obj3 = 0 ;
13746 PyObject * obj4 = 0 ;
13747 PyObject * obj5 = 0 ;
13748 char * kwnames[] = {
13749 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13750 };
13751
13752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13754 if (!SWIG_IsOK(res1)) {
13755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13756 }
13757 arg1 = reinterpret_cast< wxImage * >(argp1);
13758 {
13759 arg2 = &temp2;
13760 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13761 }
13762 {
13763 arg3 = &temp3;
13764 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13765 }
13766 if (obj3) {
13767 ecode4 = SWIG_AsVal_int(obj3, &val4);
13768 if (!SWIG_IsOK(ecode4)) {
13769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13770 }
13771 arg4 = static_cast< int >(val4);
13772 }
13773 if (obj4) {
13774 ecode5 = SWIG_AsVal_int(obj4, &val5);
13775 if (!SWIG_IsOK(ecode5)) {
13776 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13777 }
13778 arg5 = static_cast< int >(val5);
13779 }
13780 if (obj5) {
13781 ecode6 = SWIG_AsVal_int(obj5, &val6);
13782 if (!SWIG_IsOK(ecode6)) {
13783 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13784 }
13785 arg6 = static_cast< int >(val6);
13786 }
13787 {
13788 PyThreadState* __tstate = wxPyBeginAllowThreads();
13789 {
13790 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13791 result = (wxImage *) &_result_ref;
13792 }
13793 wxPyEndAllowThreads(__tstate);
13794 if (PyErr_Occurred()) SWIG_fail;
13795 }
13796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13797 return resultobj;
13798 fail:
13799 return NULL;
13800 }
13801
13802
13803 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13804 PyObject *resultobj = 0;
13805 wxImage *arg1 = (wxImage *) 0 ;
13806 int arg2 ;
13807 int arg3 ;
13808 byte arg4 ;
13809 byte arg5 ;
13810 byte arg6 ;
13811 void *argp1 = 0 ;
13812 int res1 = 0 ;
13813 int val2 ;
13814 int ecode2 = 0 ;
13815 int val3 ;
13816 int ecode3 = 0 ;
13817 unsigned char val4 ;
13818 int ecode4 = 0 ;
13819 unsigned char val5 ;
13820 int ecode5 = 0 ;
13821 unsigned char val6 ;
13822 int ecode6 = 0 ;
13823 PyObject * obj0 = 0 ;
13824 PyObject * obj1 = 0 ;
13825 PyObject * obj2 = 0 ;
13826 PyObject * obj3 = 0 ;
13827 PyObject * obj4 = 0 ;
13828 PyObject * obj5 = 0 ;
13829 char * kwnames[] = {
13830 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13831 };
13832
13833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13835 if (!SWIG_IsOK(res1)) {
13836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13837 }
13838 arg1 = reinterpret_cast< wxImage * >(argp1);
13839 ecode2 = SWIG_AsVal_int(obj1, &val2);
13840 if (!SWIG_IsOK(ecode2)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13842 }
13843 arg2 = static_cast< int >(val2);
13844 ecode3 = SWIG_AsVal_int(obj2, &val3);
13845 if (!SWIG_IsOK(ecode3)) {
13846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13847 }
13848 arg3 = static_cast< int >(val3);
13849 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13850 if (!SWIG_IsOK(ecode4)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13852 }
13853 arg4 = static_cast< byte >(val4);
13854 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13855 if (!SWIG_IsOK(ecode5)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13857 }
13858 arg5 = static_cast< byte >(val5);
13859 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13860 if (!SWIG_IsOK(ecode6)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13862 }
13863 arg6 = static_cast< byte >(val6);
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13867 wxPyEndAllowThreads(__tstate);
13868 if (PyErr_Occurred()) SWIG_fail;
13869 }
13870 resultobj = SWIG_Py_Void();
13871 return resultobj;
13872 fail:
13873 return NULL;
13874 }
13875
13876
13877 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13878 PyObject *resultobj = 0;
13879 wxImage *arg1 = (wxImage *) 0 ;
13880 wxRect *arg2 = 0 ;
13881 byte arg3 ;
13882 byte arg4 ;
13883 byte arg5 ;
13884 void *argp1 = 0 ;
13885 int res1 = 0 ;
13886 wxRect temp2 ;
13887 unsigned char val3 ;
13888 int ecode3 = 0 ;
13889 unsigned char val4 ;
13890 int ecode4 = 0 ;
13891 unsigned char val5 ;
13892 int ecode5 = 0 ;
13893 PyObject * obj0 = 0 ;
13894 PyObject * obj1 = 0 ;
13895 PyObject * obj2 = 0 ;
13896 PyObject * obj3 = 0 ;
13897 PyObject * obj4 = 0 ;
13898 char * kwnames[] = {
13899 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13900 };
13901
13902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13904 if (!SWIG_IsOK(res1)) {
13905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13906 }
13907 arg1 = reinterpret_cast< wxImage * >(argp1);
13908 {
13909 arg2 = &temp2;
13910 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13911 }
13912 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13913 if (!SWIG_IsOK(ecode3)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13915 }
13916 arg3 = static_cast< byte >(val3);
13917 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13918 if (!SWIG_IsOK(ecode4)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13920 }
13921 arg4 = static_cast< byte >(val4);
13922 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13923 if (!SWIG_IsOK(ecode5)) {
13924 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13925 }
13926 arg5 = static_cast< byte >(val5);
13927 {
13928 PyThreadState* __tstate = wxPyBeginAllowThreads();
13929 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 resultobj = SWIG_Py_Void();
13934 return resultobj;
13935 fail:
13936 return NULL;
13937 }
13938
13939
13940 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13941 PyObject *resultobj = 0;
13942 wxImage *arg1 = (wxImage *) 0 ;
13943 int arg2 ;
13944 int arg3 ;
13945 byte result;
13946 void *argp1 = 0 ;
13947 int res1 = 0 ;
13948 int val2 ;
13949 int ecode2 = 0 ;
13950 int val3 ;
13951 int ecode3 = 0 ;
13952 PyObject * obj0 = 0 ;
13953 PyObject * obj1 = 0 ;
13954 PyObject * obj2 = 0 ;
13955 char * kwnames[] = {
13956 (char *) "self",(char *) "x",(char *) "y", NULL
13957 };
13958
13959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13961 if (!SWIG_IsOK(res1)) {
13962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13963 }
13964 arg1 = reinterpret_cast< wxImage * >(argp1);
13965 ecode2 = SWIG_AsVal_int(obj1, &val2);
13966 if (!SWIG_IsOK(ecode2)) {
13967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13968 }
13969 arg2 = static_cast< int >(val2);
13970 ecode3 = SWIG_AsVal_int(obj2, &val3);
13971 if (!SWIG_IsOK(ecode3)) {
13972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13973 }
13974 arg3 = static_cast< int >(val3);
13975 {
13976 PyThreadState* __tstate = wxPyBeginAllowThreads();
13977 result = (byte)(arg1)->GetRed(arg2,arg3);
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13989 PyObject *resultobj = 0;
13990 wxImage *arg1 = (wxImage *) 0 ;
13991 int arg2 ;
13992 int arg3 ;
13993 byte result;
13994 void *argp1 = 0 ;
13995 int res1 = 0 ;
13996 int val2 ;
13997 int ecode2 = 0 ;
13998 int val3 ;
13999 int ecode3 = 0 ;
14000 PyObject * obj0 = 0 ;
14001 PyObject * obj1 = 0 ;
14002 PyObject * obj2 = 0 ;
14003 char * kwnames[] = {
14004 (char *) "self",(char *) "x",(char *) "y", NULL
14005 };
14006
14007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14009 if (!SWIG_IsOK(res1)) {
14010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14011 }
14012 arg1 = reinterpret_cast< wxImage * >(argp1);
14013 ecode2 = SWIG_AsVal_int(obj1, &val2);
14014 if (!SWIG_IsOK(ecode2)) {
14015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14016 }
14017 arg2 = static_cast< int >(val2);
14018 ecode3 = SWIG_AsVal_int(obj2, &val3);
14019 if (!SWIG_IsOK(ecode3)) {
14020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14021 }
14022 arg3 = static_cast< int >(val3);
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 result = (byte)(arg1)->GetGreen(arg2,arg3);
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14030 return resultobj;
14031 fail:
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj = 0;
14038 wxImage *arg1 = (wxImage *) 0 ;
14039 int arg2 ;
14040 int arg3 ;
14041 byte result;
14042 void *argp1 = 0 ;
14043 int res1 = 0 ;
14044 int val2 ;
14045 int ecode2 = 0 ;
14046 int val3 ;
14047 int ecode3 = 0 ;
14048 PyObject * obj0 = 0 ;
14049 PyObject * obj1 = 0 ;
14050 PyObject * obj2 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "x",(char *) "y", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14059 }
14060 arg1 = reinterpret_cast< wxImage * >(argp1);
14061 ecode2 = SWIG_AsVal_int(obj1, &val2);
14062 if (!SWIG_IsOK(ecode2)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14064 }
14065 arg2 = static_cast< int >(val2);
14066 ecode3 = SWIG_AsVal_int(obj2, &val3);
14067 if (!SWIG_IsOK(ecode3)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14069 }
14070 arg3 = static_cast< int >(val3);
14071 {
14072 PyThreadState* __tstate = wxPyBeginAllowThreads();
14073 result = (byte)(arg1)->GetBlue(arg2,arg3);
14074 wxPyEndAllowThreads(__tstate);
14075 if (PyErr_Occurred()) SWIG_fail;
14076 }
14077 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14078 return resultobj;
14079 fail:
14080 return NULL;
14081 }
14082
14083
14084 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14085 PyObject *resultobj = 0;
14086 wxImage *arg1 = (wxImage *) 0 ;
14087 int arg2 ;
14088 int arg3 ;
14089 byte arg4 ;
14090 void *argp1 = 0 ;
14091 int res1 = 0 ;
14092 int val2 ;
14093 int ecode2 = 0 ;
14094 int val3 ;
14095 int ecode3 = 0 ;
14096 unsigned char val4 ;
14097 int ecode4 = 0 ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 PyObject * obj2 = 0 ;
14101 PyObject * obj3 = 0 ;
14102 char * kwnames[] = {
14103 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14104 };
14105
14106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14108 if (!SWIG_IsOK(res1)) {
14109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14110 }
14111 arg1 = reinterpret_cast< wxImage * >(argp1);
14112 ecode2 = SWIG_AsVal_int(obj1, &val2);
14113 if (!SWIG_IsOK(ecode2)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14115 }
14116 arg2 = static_cast< int >(val2);
14117 ecode3 = SWIG_AsVal_int(obj2, &val3);
14118 if (!SWIG_IsOK(ecode3)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14120 }
14121 arg3 = static_cast< int >(val3);
14122 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14123 if (!SWIG_IsOK(ecode4)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14125 }
14126 arg4 = static_cast< byte >(val4);
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 (arg1)->SetAlpha(arg2,arg3,arg4);
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_Py_Void();
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj = 0;
14142 wxImage *arg1 = (wxImage *) 0 ;
14143 int arg2 ;
14144 int arg3 ;
14145 byte result;
14146 void *argp1 = 0 ;
14147 int res1 = 0 ;
14148 int val2 ;
14149 int ecode2 = 0 ;
14150 int val3 ;
14151 int ecode3 = 0 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 PyObject * obj2 = 0 ;
14155 char * kwnames[] = {
14156 (char *) "self",(char *) "x",(char *) "y", NULL
14157 };
14158
14159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14161 if (!SWIG_IsOK(res1)) {
14162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14163 }
14164 arg1 = reinterpret_cast< wxImage * >(argp1);
14165 ecode2 = SWIG_AsVal_int(obj1, &val2);
14166 if (!SWIG_IsOK(ecode2)) {
14167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14168 }
14169 arg2 = static_cast< int >(val2);
14170 ecode3 = SWIG_AsVal_int(obj2, &val3);
14171 if (!SWIG_IsOK(ecode3)) {
14172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14173 }
14174 arg3 = static_cast< int >(val3);
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14189 PyObject *resultobj = 0;
14190 wxImage *arg1 = (wxImage *) 0 ;
14191 bool result;
14192 void *argp1 = 0 ;
14193 int res1 = 0 ;
14194 PyObject *swig_obj[1] ;
14195
14196 if (!args) SWIG_fail;
14197 swig_obj[0] = args;
14198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14199 if (!SWIG_IsOK(res1)) {
14200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14201 }
14202 arg1 = reinterpret_cast< wxImage * >(argp1);
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 result = (bool)(arg1)->HasAlpha();
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 {
14210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14211 }
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14219 PyObject *resultobj = 0;
14220 wxImage *arg1 = (wxImage *) 0 ;
14221 void *argp1 = 0 ;
14222 int res1 = 0 ;
14223 PyObject *swig_obj[1] ;
14224
14225 if (!args) SWIG_fail;
14226 swig_obj[0] = args;
14227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14228 if (!SWIG_IsOK(res1)) {
14229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14230 }
14231 arg1 = reinterpret_cast< wxImage * >(argp1);
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 (arg1)->InitAlpha();
14235 wxPyEndAllowThreads(__tstate);
14236 if (PyErr_Occurred()) SWIG_fail;
14237 }
14238 resultobj = SWIG_Py_Void();
14239 return resultobj;
14240 fail:
14241 return NULL;
14242 }
14243
14244
14245 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14246 PyObject *resultobj = 0;
14247 wxImage *arg1 = (wxImage *) 0 ;
14248 int arg2 ;
14249 int arg3 ;
14250 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14251 bool result;
14252 void *argp1 = 0 ;
14253 int res1 = 0 ;
14254 int val2 ;
14255 int ecode2 = 0 ;
14256 int val3 ;
14257 int ecode3 = 0 ;
14258 unsigned char val4 ;
14259 int ecode4 = 0 ;
14260 PyObject * obj0 = 0 ;
14261 PyObject * obj1 = 0 ;
14262 PyObject * obj2 = 0 ;
14263 PyObject * obj3 = 0 ;
14264 char * kwnames[] = {
14265 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14266 };
14267
14268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14270 if (!SWIG_IsOK(res1)) {
14271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14272 }
14273 arg1 = reinterpret_cast< wxImage * >(argp1);
14274 ecode2 = SWIG_AsVal_int(obj1, &val2);
14275 if (!SWIG_IsOK(ecode2)) {
14276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14277 }
14278 arg2 = static_cast< int >(val2);
14279 ecode3 = SWIG_AsVal_int(obj2, &val3);
14280 if (!SWIG_IsOK(ecode3)) {
14281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14282 }
14283 arg3 = static_cast< int >(val3);
14284 if (obj3) {
14285 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14286 if (!SWIG_IsOK(ecode4)) {
14287 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14288 }
14289 arg4 = static_cast< byte >(val4);
14290 }
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 {
14298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14299 }
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj = 0;
14308 wxImage *arg1 = (wxImage *) 0 ;
14309 byte *arg2 = (byte *) 0 ;
14310 byte *arg3 = (byte *) 0 ;
14311 byte *arg4 = (byte *) 0 ;
14312 byte arg5 = (byte) 0 ;
14313 byte arg6 = (byte) 0 ;
14314 byte arg7 = (byte) 0 ;
14315 bool result;
14316 void *argp1 = 0 ;
14317 int res1 = 0 ;
14318 byte temp2 ;
14319 int res2 = SWIG_TMPOBJ ;
14320 byte temp3 ;
14321 int res3 = SWIG_TMPOBJ ;
14322 byte temp4 ;
14323 int res4 = SWIG_TMPOBJ ;
14324 unsigned char val5 ;
14325 int ecode5 = 0 ;
14326 unsigned char val6 ;
14327 int ecode6 = 0 ;
14328 unsigned char val7 ;
14329 int ecode7 = 0 ;
14330 PyObject * obj0 = 0 ;
14331 PyObject * obj1 = 0 ;
14332 PyObject * obj2 = 0 ;
14333 PyObject * obj3 = 0 ;
14334 char * kwnames[] = {
14335 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14336 };
14337
14338 arg2 = &temp2;
14339 arg3 = &temp3;
14340 arg4 = &temp4;
14341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14343 if (!SWIG_IsOK(res1)) {
14344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14345 }
14346 arg1 = reinterpret_cast< wxImage * >(argp1);
14347 if (obj1) {
14348 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14349 if (!SWIG_IsOK(ecode5)) {
14350 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14351 }
14352 arg5 = static_cast< byte >(val5);
14353 }
14354 if (obj2) {
14355 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14356 if (!SWIG_IsOK(ecode6)) {
14357 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14358 }
14359 arg6 = static_cast< byte >(val6);
14360 }
14361 if (obj3) {
14362 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14363 if (!SWIG_IsOK(ecode7)) {
14364 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14365 }
14366 arg7 = static_cast< byte >(val7);
14367 }
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 {
14375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14376 }
14377 if (SWIG_IsTmpObj(res2)) {
14378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14379 } else {
14380 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14382 }
14383 if (SWIG_IsTmpObj(res3)) {
14384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14385 } else {
14386 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14388 }
14389 if (SWIG_IsTmpObj(res4)) {
14390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14391 } else {
14392 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14394 }
14395 return resultobj;
14396 fail:
14397 return NULL;
14398 }
14399
14400
14401 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14402 PyObject *resultobj = 0;
14403 wxImage *arg1 = (wxImage *) 0 ;
14404 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14405 bool result;
14406 void *argp1 = 0 ;
14407 int res1 = 0 ;
14408 unsigned char val2 ;
14409 int ecode2 = 0 ;
14410 PyObject * obj0 = 0 ;
14411 PyObject * obj1 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "threshold", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14420 }
14421 arg1 = reinterpret_cast< wxImage * >(argp1);
14422 if (obj1) {
14423 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14424 if (!SWIG_IsOK(ecode2)) {
14425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14426 }
14427 arg2 = static_cast< byte >(val2);
14428 }
14429 {
14430 PyThreadState* __tstate = wxPyBeginAllowThreads();
14431 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14432 wxPyEndAllowThreads(__tstate);
14433 if (PyErr_Occurred()) SWIG_fail;
14434 }
14435 {
14436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14437 }
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14445 PyObject *resultobj = 0;
14446 wxImage *arg1 = (wxImage *) 0 ;
14447 byte arg2 ;
14448 byte arg3 ;
14449 byte arg4 ;
14450 bool result;
14451 void *argp1 = 0 ;
14452 int res1 = 0 ;
14453 unsigned char val2 ;
14454 int ecode2 = 0 ;
14455 unsigned char val3 ;
14456 int ecode3 = 0 ;
14457 unsigned char val4 ;
14458 int ecode4 = 0 ;
14459 PyObject * obj0 = 0 ;
14460 PyObject * obj1 = 0 ;
14461 PyObject * obj2 = 0 ;
14462 PyObject * obj3 = 0 ;
14463 char * kwnames[] = {
14464 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14465 };
14466
14467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14469 if (!SWIG_IsOK(res1)) {
14470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14471 }
14472 arg1 = reinterpret_cast< wxImage * >(argp1);
14473 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14474 if (!SWIG_IsOK(ecode2)) {
14475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14476 }
14477 arg2 = static_cast< byte >(val2);
14478 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14479 if (!SWIG_IsOK(ecode3)) {
14480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14481 }
14482 arg3 = static_cast< byte >(val3);
14483 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14484 if (!SWIG_IsOK(ecode4)) {
14485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14486 }
14487 arg4 = static_cast< byte >(val4);
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14491 wxPyEndAllowThreads(__tstate);
14492 if (PyErr_Occurred()) SWIG_fail;
14493 }
14494 {
14495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14496 }
14497 return resultobj;
14498 fail:
14499 return NULL;
14500 }
14501
14502
14503 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14504 PyObject *resultobj = 0;
14505 wxImage *arg1 = (wxImage *) 0 ;
14506 wxImage *arg2 = 0 ;
14507 byte arg3 ;
14508 byte arg4 ;
14509 byte arg5 ;
14510 bool result;
14511 void *argp1 = 0 ;
14512 int res1 = 0 ;
14513 void *argp2 = 0 ;
14514 int res2 = 0 ;
14515 unsigned char val3 ;
14516 int ecode3 = 0 ;
14517 unsigned char val4 ;
14518 int ecode4 = 0 ;
14519 unsigned char val5 ;
14520 int ecode5 = 0 ;
14521 PyObject * obj0 = 0 ;
14522 PyObject * obj1 = 0 ;
14523 PyObject * obj2 = 0 ;
14524 PyObject * obj3 = 0 ;
14525 PyObject * obj4 = 0 ;
14526 char * kwnames[] = {
14527 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14528 };
14529
14530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14532 if (!SWIG_IsOK(res1)) {
14533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14534 }
14535 arg1 = reinterpret_cast< wxImage * >(argp1);
14536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14537 if (!SWIG_IsOK(res2)) {
14538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14539 }
14540 if (!argp2) {
14541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14542 }
14543 arg2 = reinterpret_cast< wxImage * >(argp2);
14544 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14545 if (!SWIG_IsOK(ecode3)) {
14546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14547 }
14548 arg3 = static_cast< byte >(val3);
14549 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14550 if (!SWIG_IsOK(ecode4)) {
14551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14552 }
14553 arg4 = static_cast< byte >(val4);
14554 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14555 if (!SWIG_IsOK(ecode5)) {
14556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14557 }
14558 arg5 = static_cast< byte >(val5);
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 {
14566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14567 }
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj = 0;
14576 wxString *arg1 = 0 ;
14577 bool result;
14578 bool temp1 = false ;
14579 PyObject * obj0 = 0 ;
14580 char * kwnames[] = {
14581 (char *) "filename", NULL
14582 };
14583
14584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14585 {
14586 arg1 = wxString_in_helper(obj0);
14587 if (arg1 == NULL) SWIG_fail;
14588 temp1 = true;
14589 }
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 {
14597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14598 }
14599 {
14600 if (temp1)
14601 delete arg1;
14602 }
14603 return resultobj;
14604 fail:
14605 {
14606 if (temp1)
14607 delete arg1;
14608 }
14609 return NULL;
14610 }
14611
14612
14613 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj = 0;
14615 wxString *arg1 = 0 ;
14616 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14617 int result;
14618 bool temp1 = false ;
14619 long val2 ;
14620 int ecode2 = 0 ;
14621 PyObject * obj0 = 0 ;
14622 PyObject * obj1 = 0 ;
14623 char * kwnames[] = {
14624 (char *) "filename",(char *) "type", NULL
14625 };
14626
14627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14628 {
14629 arg1 = wxString_in_helper(obj0);
14630 if (arg1 == NULL) SWIG_fail;
14631 temp1 = true;
14632 }
14633 if (obj1) {
14634 ecode2 = SWIG_AsVal_long(obj1, &val2);
14635 if (!SWIG_IsOK(ecode2)) {
14636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14637 }
14638 arg2 = static_cast< long >(val2);
14639 }
14640 {
14641 PyThreadState* __tstate = wxPyBeginAllowThreads();
14642 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14643 wxPyEndAllowThreads(__tstate);
14644 if (PyErr_Occurred()) SWIG_fail;
14645 }
14646 resultobj = SWIG_From_int(static_cast< int >(result));
14647 {
14648 if (temp1)
14649 delete arg1;
14650 }
14651 return resultobj;
14652 fail:
14653 {
14654 if (temp1)
14655 delete arg1;
14656 }
14657 return NULL;
14658 }
14659
14660
14661 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14662 PyObject *resultobj = 0;
14663 wxImage *arg1 = (wxImage *) 0 ;
14664 wxString *arg2 = 0 ;
14665 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14666 int arg4 = (int) -1 ;
14667 bool result;
14668 void *argp1 = 0 ;
14669 int res1 = 0 ;
14670 bool temp2 = false ;
14671 long val3 ;
14672 int ecode3 = 0 ;
14673 int val4 ;
14674 int ecode4 = 0 ;
14675 PyObject * obj0 = 0 ;
14676 PyObject * obj1 = 0 ;
14677 PyObject * obj2 = 0 ;
14678 PyObject * obj3 = 0 ;
14679 char * kwnames[] = {
14680 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14681 };
14682
14683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14685 if (!SWIG_IsOK(res1)) {
14686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14687 }
14688 arg1 = reinterpret_cast< wxImage * >(argp1);
14689 {
14690 arg2 = wxString_in_helper(obj1);
14691 if (arg2 == NULL) SWIG_fail;
14692 temp2 = true;
14693 }
14694 if (obj2) {
14695 ecode3 = SWIG_AsVal_long(obj2, &val3);
14696 if (!SWIG_IsOK(ecode3)) {
14697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14698 }
14699 arg3 = static_cast< long >(val3);
14700 }
14701 if (obj3) {
14702 ecode4 = SWIG_AsVal_int(obj3, &val4);
14703 if (!SWIG_IsOK(ecode4)) {
14704 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14705 }
14706 arg4 = static_cast< int >(val4);
14707 }
14708 {
14709 PyThreadState* __tstate = wxPyBeginAllowThreads();
14710 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 {
14715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14716 }
14717 {
14718 if (temp2)
14719 delete arg2;
14720 }
14721 return resultobj;
14722 fail:
14723 {
14724 if (temp2)
14725 delete arg2;
14726 }
14727 return NULL;
14728 }
14729
14730
14731 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj = 0;
14733 wxImage *arg1 = (wxImage *) 0 ;
14734 wxString *arg2 = 0 ;
14735 wxString *arg3 = 0 ;
14736 int arg4 = (int) -1 ;
14737 bool result;
14738 void *argp1 = 0 ;
14739 int res1 = 0 ;
14740 bool temp2 = false ;
14741 bool temp3 = false ;
14742 int val4 ;
14743 int ecode4 = 0 ;
14744 PyObject * obj0 = 0 ;
14745 PyObject * obj1 = 0 ;
14746 PyObject * obj2 = 0 ;
14747 PyObject * obj3 = 0 ;
14748 char * kwnames[] = {
14749 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14750 };
14751
14752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14754 if (!SWIG_IsOK(res1)) {
14755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14756 }
14757 arg1 = reinterpret_cast< wxImage * >(argp1);
14758 {
14759 arg2 = wxString_in_helper(obj1);
14760 if (arg2 == NULL) SWIG_fail;
14761 temp2 = true;
14762 }
14763 {
14764 arg3 = wxString_in_helper(obj2);
14765 if (arg3 == NULL) SWIG_fail;
14766 temp3 = true;
14767 }
14768 if (obj3) {
14769 ecode4 = SWIG_AsVal_int(obj3, &val4);
14770 if (!SWIG_IsOK(ecode4)) {
14771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14772 }
14773 arg4 = static_cast< int >(val4);
14774 }
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 {
14782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14783 }
14784 {
14785 if (temp2)
14786 delete arg2;
14787 }
14788 {
14789 if (temp3)
14790 delete arg3;
14791 }
14792 return resultobj;
14793 fail:
14794 {
14795 if (temp2)
14796 delete arg2;
14797 }
14798 {
14799 if (temp3)
14800 delete arg3;
14801 }
14802 return NULL;
14803 }
14804
14805
14806 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14807 PyObject *resultobj = 0;
14808 wxImage *arg1 = (wxImage *) 0 ;
14809 wxString *arg2 = 0 ;
14810 int arg3 ;
14811 bool result;
14812 void *argp1 = 0 ;
14813 int res1 = 0 ;
14814 bool temp2 = false ;
14815 int val3 ;
14816 int ecode3 = 0 ;
14817 PyObject * obj0 = 0 ;
14818 PyObject * obj1 = 0 ;
14819 PyObject * obj2 = 0 ;
14820 char * kwnames[] = {
14821 (char *) "self",(char *) "name",(char *) "type", NULL
14822 };
14823
14824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14826 if (!SWIG_IsOK(res1)) {
14827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14828 }
14829 arg1 = reinterpret_cast< wxImage * >(argp1);
14830 {
14831 arg2 = wxString_in_helper(obj1);
14832 if (arg2 == NULL) SWIG_fail;
14833 temp2 = true;
14834 }
14835 ecode3 = SWIG_AsVal_int(obj2, &val3);
14836 if (!SWIG_IsOK(ecode3)) {
14837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14838 }
14839 arg3 = static_cast< int >(val3);
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 {
14847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14848 }
14849 {
14850 if (temp2)
14851 delete arg2;
14852 }
14853 return resultobj;
14854 fail:
14855 {
14856 if (temp2)
14857 delete arg2;
14858 }
14859 return NULL;
14860 }
14861
14862
14863 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj = 0;
14865 wxImage *arg1 = (wxImage *) 0 ;
14866 wxString *arg2 = 0 ;
14867 wxString *arg3 = 0 ;
14868 bool result;
14869 void *argp1 = 0 ;
14870 int res1 = 0 ;
14871 bool temp2 = false ;
14872 bool temp3 = false ;
14873 PyObject * obj0 = 0 ;
14874 PyObject * obj1 = 0 ;
14875 PyObject * obj2 = 0 ;
14876 char * kwnames[] = {
14877 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14878 };
14879
14880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14882 if (!SWIG_IsOK(res1)) {
14883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14884 }
14885 arg1 = reinterpret_cast< wxImage * >(argp1);
14886 {
14887 arg2 = wxString_in_helper(obj1);
14888 if (arg2 == NULL) SWIG_fail;
14889 temp2 = true;
14890 }
14891 {
14892 arg3 = wxString_in_helper(obj2);
14893 if (arg3 == NULL) SWIG_fail;
14894 temp3 = true;
14895 }
14896 {
14897 PyThreadState* __tstate = wxPyBeginAllowThreads();
14898 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14899 wxPyEndAllowThreads(__tstate);
14900 if (PyErr_Occurred()) SWIG_fail;
14901 }
14902 {
14903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14904 }
14905 {
14906 if (temp2)
14907 delete arg2;
14908 }
14909 {
14910 if (temp3)
14911 delete arg3;
14912 }
14913 return resultobj;
14914 fail:
14915 {
14916 if (temp2)
14917 delete arg2;
14918 }
14919 {
14920 if (temp3)
14921 delete arg3;
14922 }
14923 return NULL;
14924 }
14925
14926
14927 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14928 PyObject *resultobj = 0;
14929 wxInputStream *arg1 = 0 ;
14930 bool result;
14931 wxPyInputStream *temp1 ;
14932 bool created1 ;
14933 PyObject * obj0 = 0 ;
14934 char * kwnames[] = {
14935 (char *) "stream", NULL
14936 };
14937
14938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14939 {
14940 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14941 arg1 = temp1->m_wxis;
14942 created1 = false;
14943 } else {
14944 PyErr_Clear(); // clear the failure of the wxPyConvert above
14945 arg1 = wxPyCBInputStream_create(obj0, false);
14946 if (arg1 == NULL) {
14947 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14948 SWIG_fail;
14949 }
14950 created1 = true;
14951 }
14952 }
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 result = (bool)wxImage::CanRead(*arg1);
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 {
14960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14961 }
14962 {
14963 if (created1) delete arg1;
14964 }
14965 return resultobj;
14966 fail:
14967 {
14968 if (created1) delete arg1;
14969 }
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj = 0;
14976 wxImage *arg1 = (wxImage *) 0 ;
14977 wxInputStream *arg2 = 0 ;
14978 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14979 int arg4 = (int) -1 ;
14980 bool result;
14981 void *argp1 = 0 ;
14982 int res1 = 0 ;
14983 wxPyInputStream *temp2 ;
14984 bool created2 ;
14985 long val3 ;
14986 int ecode3 = 0 ;
14987 int val4 ;
14988 int ecode4 = 0 ;
14989 PyObject * obj0 = 0 ;
14990 PyObject * obj1 = 0 ;
14991 PyObject * obj2 = 0 ;
14992 PyObject * obj3 = 0 ;
14993 char * kwnames[] = {
14994 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14995 };
14996
14997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14999 if (!SWIG_IsOK(res1)) {
15000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15001 }
15002 arg1 = reinterpret_cast< wxImage * >(argp1);
15003 {
15004 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15005 arg2 = temp2->m_wxis;
15006 created2 = false;
15007 } else {
15008 PyErr_Clear(); // clear the failure of the wxPyConvert above
15009 arg2 = wxPyCBInputStream_create(obj1, false);
15010 if (arg2 == NULL) {
15011 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15012 SWIG_fail;
15013 }
15014 created2 = true;
15015 }
15016 }
15017 if (obj2) {
15018 ecode3 = SWIG_AsVal_long(obj2, &val3);
15019 if (!SWIG_IsOK(ecode3)) {
15020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15021 }
15022 arg3 = static_cast< long >(val3);
15023 }
15024 if (obj3) {
15025 ecode4 = SWIG_AsVal_int(obj3, &val4);
15026 if (!SWIG_IsOK(ecode4)) {
15027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15028 }
15029 arg4 = static_cast< int >(val4);
15030 }
15031 {
15032 PyThreadState* __tstate = wxPyBeginAllowThreads();
15033 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15034 wxPyEndAllowThreads(__tstate);
15035 if (PyErr_Occurred()) SWIG_fail;
15036 }
15037 {
15038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15039 }
15040 {
15041 if (created2) delete arg2;
15042 }
15043 return resultobj;
15044 fail:
15045 {
15046 if (created2) delete arg2;
15047 }
15048 return NULL;
15049 }
15050
15051
15052 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15053 PyObject *resultobj = 0;
15054 wxImage *arg1 = (wxImage *) 0 ;
15055 wxInputStream *arg2 = 0 ;
15056 wxString *arg3 = 0 ;
15057 int arg4 = (int) -1 ;
15058 bool result;
15059 void *argp1 = 0 ;
15060 int res1 = 0 ;
15061 wxPyInputStream *temp2 ;
15062 bool created2 ;
15063 bool temp3 = false ;
15064 int val4 ;
15065 int ecode4 = 0 ;
15066 PyObject * obj0 = 0 ;
15067 PyObject * obj1 = 0 ;
15068 PyObject * obj2 = 0 ;
15069 PyObject * obj3 = 0 ;
15070 char * kwnames[] = {
15071 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15072 };
15073
15074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15076 if (!SWIG_IsOK(res1)) {
15077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15078 }
15079 arg1 = reinterpret_cast< wxImage * >(argp1);
15080 {
15081 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15082 arg2 = temp2->m_wxis;
15083 created2 = false;
15084 } else {
15085 PyErr_Clear(); // clear the failure of the wxPyConvert above
15086 arg2 = wxPyCBInputStream_create(obj1, false);
15087 if (arg2 == NULL) {
15088 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15089 SWIG_fail;
15090 }
15091 created2 = true;
15092 }
15093 }
15094 {
15095 arg3 = wxString_in_helper(obj2);
15096 if (arg3 == NULL) SWIG_fail;
15097 temp3 = true;
15098 }
15099 if (obj3) {
15100 ecode4 = SWIG_AsVal_int(obj3, &val4);
15101 if (!SWIG_IsOK(ecode4)) {
15102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15103 }
15104 arg4 = static_cast< int >(val4);
15105 }
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15109 wxPyEndAllowThreads(__tstate);
15110 if (PyErr_Occurred()) SWIG_fail;
15111 }
15112 {
15113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15114 }
15115 {
15116 if (created2) delete arg2;
15117 }
15118 {
15119 if (temp3)
15120 delete arg3;
15121 }
15122 return resultobj;
15123 fail:
15124 {
15125 if (created2) delete arg2;
15126 }
15127 {
15128 if (temp3)
15129 delete arg3;
15130 }
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15136 PyObject *resultobj = 0;
15137 wxImage *arg1 = (wxImage *) 0 ;
15138 bool result;
15139 void *argp1 = 0 ;
15140 int res1 = 0 ;
15141 PyObject *swig_obj[1] ;
15142
15143 if (!args) SWIG_fail;
15144 swig_obj[0] = args;
15145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15146 if (!SWIG_IsOK(res1)) {
15147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15148 }
15149 arg1 = reinterpret_cast< wxImage * >(argp1);
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (bool)(arg1)->Ok();
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 {
15157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15158 }
15159 return resultobj;
15160 fail:
15161 return NULL;
15162 }
15163
15164
15165 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15166 PyObject *resultobj = 0;
15167 wxImage *arg1 = (wxImage *) 0 ;
15168 int result;
15169 void *argp1 = 0 ;
15170 int res1 = 0 ;
15171 PyObject *swig_obj[1] ;
15172
15173 if (!args) SWIG_fail;
15174 swig_obj[0] = args;
15175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15176 if (!SWIG_IsOK(res1)) {
15177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15178 }
15179 arg1 = reinterpret_cast< wxImage * >(argp1);
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (int)(arg1)->GetWidth();
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 resultobj = SWIG_From_int(static_cast< int >(result));
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 PyObject *resultobj = 0;
15195 wxImage *arg1 = (wxImage *) 0 ;
15196 int result;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 PyObject *swig_obj[1] ;
15200
15201 if (!args) SWIG_fail;
15202 swig_obj[0] = args;
15203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15204 if (!SWIG_IsOK(res1)) {
15205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15206 }
15207 arg1 = reinterpret_cast< wxImage * >(argp1);
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 result = (int)(arg1)->GetHeight();
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 resultobj = SWIG_From_int(static_cast< int >(result));
15215 return resultobj;
15216 fail:
15217 return NULL;
15218 }
15219
15220
15221 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15222 PyObject *resultobj = 0;
15223 wxImage *arg1 = (wxImage *) 0 ;
15224 wxSize result;
15225 void *argp1 = 0 ;
15226 int res1 = 0 ;
15227 PyObject *swig_obj[1] ;
15228
15229 if (!args) SWIG_fail;
15230 swig_obj[0] = args;
15231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15232 if (!SWIG_IsOK(res1)) {
15233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15234 }
15235 arg1 = reinterpret_cast< wxImage * >(argp1);
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 result = wxImage_GetSize(arg1);
15239 wxPyEndAllowThreads(__tstate);
15240 if (PyErr_Occurred()) SWIG_fail;
15241 }
15242 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15243 return resultobj;
15244 fail:
15245 return NULL;
15246 }
15247
15248
15249 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15250 PyObject *resultobj = 0;
15251 wxImage *arg1 = (wxImage *) 0 ;
15252 wxRect *arg2 = 0 ;
15253 SwigValueWrapper<wxImage > result;
15254 void *argp1 = 0 ;
15255 int res1 = 0 ;
15256 wxRect temp2 ;
15257 PyObject * obj0 = 0 ;
15258 PyObject * obj1 = 0 ;
15259 char * kwnames[] = {
15260 (char *) "self",(char *) "rect", NULL
15261 };
15262
15263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15265 if (!SWIG_IsOK(res1)) {
15266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15267 }
15268 arg1 = reinterpret_cast< wxImage * >(argp1);
15269 {
15270 arg2 = &temp2;
15271 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15272 }
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj = 0;
15288 wxImage *arg1 = (wxImage *) 0 ;
15289 wxSize *arg2 = 0 ;
15290 wxPoint *arg3 = 0 ;
15291 int arg4 = (int) -1 ;
15292 int arg5 = (int) -1 ;
15293 int arg6 = (int) -1 ;
15294 SwigValueWrapper<wxImage > result;
15295 void *argp1 = 0 ;
15296 int res1 = 0 ;
15297 wxSize temp2 ;
15298 wxPoint temp3 ;
15299 int val4 ;
15300 int ecode4 = 0 ;
15301 int val5 ;
15302 int ecode5 = 0 ;
15303 int val6 ;
15304 int ecode6 = 0 ;
15305 PyObject * obj0 = 0 ;
15306 PyObject * obj1 = 0 ;
15307 PyObject * obj2 = 0 ;
15308 PyObject * obj3 = 0 ;
15309 PyObject * obj4 = 0 ;
15310 PyObject * obj5 = 0 ;
15311 char * kwnames[] = {
15312 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15313 };
15314
15315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15317 if (!SWIG_IsOK(res1)) {
15318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15319 }
15320 arg1 = reinterpret_cast< wxImage * >(argp1);
15321 {
15322 arg2 = &temp2;
15323 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15324 }
15325 {
15326 arg3 = &temp3;
15327 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15328 }
15329 if (obj3) {
15330 ecode4 = SWIG_AsVal_int(obj3, &val4);
15331 if (!SWIG_IsOK(ecode4)) {
15332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15333 }
15334 arg4 = static_cast< int >(val4);
15335 }
15336 if (obj4) {
15337 ecode5 = SWIG_AsVal_int(obj4, &val5);
15338 if (!SWIG_IsOK(ecode5)) {
15339 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15340 }
15341 arg5 = static_cast< int >(val5);
15342 }
15343 if (obj5) {
15344 ecode6 = SWIG_AsVal_int(obj5, &val6);
15345 if (!SWIG_IsOK(ecode6)) {
15346 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15347 }
15348 arg6 = static_cast< int >(val6);
15349 }
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15353 wxPyEndAllowThreads(__tstate);
15354 if (PyErr_Occurred()) SWIG_fail;
15355 }
15356 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15357 return resultobj;
15358 fail:
15359 return NULL;
15360 }
15361
15362
15363 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15364 PyObject *resultobj = 0;
15365 wxImage *arg1 = (wxImage *) 0 ;
15366 SwigValueWrapper<wxImage > result;
15367 void *argp1 = 0 ;
15368 int res1 = 0 ;
15369 PyObject *swig_obj[1] ;
15370
15371 if (!args) SWIG_fail;
15372 swig_obj[0] = args;
15373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15374 if (!SWIG_IsOK(res1)) {
15375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15376 }
15377 arg1 = reinterpret_cast< wxImage * >(argp1);
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (arg1)->Copy();
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj = 0;
15393 wxImage *arg1 = (wxImage *) 0 ;
15394 wxImage *arg2 = 0 ;
15395 int arg3 ;
15396 int arg4 ;
15397 void *argp1 = 0 ;
15398 int res1 = 0 ;
15399 void *argp2 = 0 ;
15400 int res2 = 0 ;
15401 int val3 ;
15402 int ecode3 = 0 ;
15403 int val4 ;
15404 int ecode4 = 0 ;
15405 PyObject * obj0 = 0 ;
15406 PyObject * obj1 = 0 ;
15407 PyObject * obj2 = 0 ;
15408 PyObject * obj3 = 0 ;
15409 char * kwnames[] = {
15410 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15411 };
15412
15413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15415 if (!SWIG_IsOK(res1)) {
15416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15417 }
15418 arg1 = reinterpret_cast< wxImage * >(argp1);
15419 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15420 if (!SWIG_IsOK(res2)) {
15421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15422 }
15423 if (!argp2) {
15424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15425 }
15426 arg2 = reinterpret_cast< wxImage * >(argp2);
15427 ecode3 = SWIG_AsVal_int(obj2, &val3);
15428 if (!SWIG_IsOK(ecode3)) {
15429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15430 }
15431 arg3 = static_cast< int >(val3);
15432 ecode4 = SWIG_AsVal_int(obj3, &val4);
15433 if (!SWIG_IsOK(ecode4)) {
15434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15435 }
15436 arg4 = static_cast< int >(val4);
15437 {
15438 PyThreadState* __tstate = wxPyBeginAllowThreads();
15439 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15440 wxPyEndAllowThreads(__tstate);
15441 if (PyErr_Occurred()) SWIG_fail;
15442 }
15443 resultobj = SWIG_Py_Void();
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15451 PyObject *resultobj = 0;
15452 wxImage *arg1 = (wxImage *) 0 ;
15453 PyObject *result = 0 ;
15454 void *argp1 = 0 ;
15455 int res1 = 0 ;
15456 PyObject *swig_obj[1] ;
15457
15458 if (!args) SWIG_fail;
15459 swig_obj[0] = args;
15460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15461 if (!SWIG_IsOK(res1)) {
15462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15463 }
15464 arg1 = reinterpret_cast< wxImage * >(argp1);
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 result = (PyObject *)wxImage_GetData(arg1);
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 resultobj = result;
15472 return resultobj;
15473 fail:
15474 return NULL;
15475 }
15476
15477
15478 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15479 PyObject *resultobj = 0;
15480 wxImage *arg1 = (wxImage *) 0 ;
15481 buffer arg2 ;
15482 int arg3 ;
15483 void *argp1 = 0 ;
15484 int res1 = 0 ;
15485 Py_ssize_t temp2 ;
15486 PyObject * obj0 = 0 ;
15487 PyObject * obj1 = 0 ;
15488 char * kwnames[] = {
15489 (char *) "self",(char *) "data", NULL
15490 };
15491
15492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15494 if (!SWIG_IsOK(res1)) {
15495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15496 }
15497 arg1 = reinterpret_cast< wxImage * >(argp1);
15498 {
15499 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15500 arg3 = (int)temp2;
15501 }
15502 {
15503 PyThreadState* __tstate = wxPyBeginAllowThreads();
15504 wxImage_SetData(arg1,arg2,arg3);
15505 wxPyEndAllowThreads(__tstate);
15506 if (PyErr_Occurred()) SWIG_fail;
15507 }
15508 resultobj = SWIG_Py_Void();
15509 return resultobj;
15510 fail:
15511 return NULL;
15512 }
15513
15514
15515 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15516 PyObject *resultobj = 0;
15517 wxImage *arg1 = (wxImage *) 0 ;
15518 PyObject *result = 0 ;
15519 void *argp1 = 0 ;
15520 int res1 = 0 ;
15521 PyObject *swig_obj[1] ;
15522
15523 if (!args) SWIG_fail;
15524 swig_obj[0] = args;
15525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15526 if (!SWIG_IsOK(res1)) {
15527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15528 }
15529 arg1 = reinterpret_cast< wxImage * >(argp1);
15530 {
15531 PyThreadState* __tstate = wxPyBeginAllowThreads();
15532 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15533 wxPyEndAllowThreads(__tstate);
15534 if (PyErr_Occurred()) SWIG_fail;
15535 }
15536 resultobj = result;
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15544 PyObject *resultobj = 0;
15545 wxImage *arg1 = (wxImage *) 0 ;
15546 buffer arg2 ;
15547 int arg3 ;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 Py_ssize_t temp2 ;
15551 PyObject * obj0 = 0 ;
15552 PyObject * obj1 = 0 ;
15553 char * kwnames[] = {
15554 (char *) "self",(char *) "data", NULL
15555 };
15556
15557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15561 }
15562 arg1 = reinterpret_cast< wxImage * >(argp1);
15563 {
15564 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15565 arg3 = (int)temp2;
15566 }
15567 {
15568 PyThreadState* __tstate = wxPyBeginAllowThreads();
15569 wxImage_SetDataBuffer(arg1,arg2,arg3);
15570 wxPyEndAllowThreads(__tstate);
15571 if (PyErr_Occurred()) SWIG_fail;
15572 }
15573 resultobj = SWIG_Py_Void();
15574 return resultobj;
15575 fail:
15576 return NULL;
15577 }
15578
15579
15580 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15581 PyObject *resultobj = 0;
15582 wxImage *arg1 = (wxImage *) 0 ;
15583 PyObject *result = 0 ;
15584 void *argp1 = 0 ;
15585 int res1 = 0 ;
15586 PyObject *swig_obj[1] ;
15587
15588 if (!args) SWIG_fail;
15589 swig_obj[0] = args;
15590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15591 if (!SWIG_IsOK(res1)) {
15592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15593 }
15594 arg1 = reinterpret_cast< wxImage * >(argp1);
15595 {
15596 PyThreadState* __tstate = wxPyBeginAllowThreads();
15597 result = (PyObject *)wxImage_GetAlphaData(arg1);
15598 wxPyEndAllowThreads(__tstate);
15599 if (PyErr_Occurred()) SWIG_fail;
15600 }
15601 resultobj = result;
15602 return resultobj;
15603 fail:
15604 return NULL;
15605 }
15606
15607
15608 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15609 PyObject *resultobj = 0;
15610 wxImage *arg1 = (wxImage *) 0 ;
15611 buffer arg2 ;
15612 int arg3 ;
15613 void *argp1 = 0 ;
15614 int res1 = 0 ;
15615 Py_ssize_t temp2 ;
15616 PyObject * obj0 = 0 ;
15617 PyObject * obj1 = 0 ;
15618 char * kwnames[] = {
15619 (char *) "self",(char *) "alpha", NULL
15620 };
15621
15622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15624 if (!SWIG_IsOK(res1)) {
15625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15626 }
15627 arg1 = reinterpret_cast< wxImage * >(argp1);
15628 {
15629 if (obj1 != Py_None) {
15630 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15631 arg3 = (int)temp2;
15632 }
15633 }
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 wxImage_SetAlphaData(arg1,arg2,arg3);
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 resultobj = SWIG_Py_Void();
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15648 PyObject *resultobj = 0;
15649 wxImage *arg1 = (wxImage *) 0 ;
15650 PyObject *result = 0 ;
15651 void *argp1 = 0 ;
15652 int res1 = 0 ;
15653 PyObject *swig_obj[1] ;
15654
15655 if (!args) SWIG_fail;
15656 swig_obj[0] = args;
15657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15658 if (!SWIG_IsOK(res1)) {
15659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15660 }
15661 arg1 = reinterpret_cast< wxImage * >(argp1);
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 resultobj = result;
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15676 PyObject *resultobj = 0;
15677 wxImage *arg1 = (wxImage *) 0 ;
15678 buffer arg2 ;
15679 int arg3 ;
15680 void *argp1 = 0 ;
15681 int res1 = 0 ;
15682 Py_ssize_t temp2 ;
15683 PyObject * obj0 = 0 ;
15684 PyObject * obj1 = 0 ;
15685 char * kwnames[] = {
15686 (char *) "self",(char *) "alpha", NULL
15687 };
15688
15689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15691 if (!SWIG_IsOK(res1)) {
15692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15693 }
15694 arg1 = reinterpret_cast< wxImage * >(argp1);
15695 {
15696 if (obj1 != Py_None) {
15697 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15698 arg3 = (int)temp2;
15699 }
15700 }
15701 {
15702 PyThreadState* __tstate = wxPyBeginAllowThreads();
15703 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15704 wxPyEndAllowThreads(__tstate);
15705 if (PyErr_Occurred()) SWIG_fail;
15706 }
15707 resultobj = SWIG_Py_Void();
15708 return resultobj;
15709 fail:
15710 return NULL;
15711 }
15712
15713
15714 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15715 PyObject *resultobj = 0;
15716 wxImage *arg1 = (wxImage *) 0 ;
15717 byte arg2 ;
15718 byte arg3 ;
15719 byte arg4 ;
15720 void *argp1 = 0 ;
15721 int res1 = 0 ;
15722 unsigned char val2 ;
15723 int ecode2 = 0 ;
15724 unsigned char val3 ;
15725 int ecode3 = 0 ;
15726 unsigned char val4 ;
15727 int ecode4 = 0 ;
15728 PyObject * obj0 = 0 ;
15729 PyObject * obj1 = 0 ;
15730 PyObject * obj2 = 0 ;
15731 PyObject * obj3 = 0 ;
15732 char * kwnames[] = {
15733 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15734 };
15735
15736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15738 if (!SWIG_IsOK(res1)) {
15739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15740 }
15741 arg1 = reinterpret_cast< wxImage * >(argp1);
15742 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15743 if (!SWIG_IsOK(ecode2)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15745 }
15746 arg2 = static_cast< byte >(val2);
15747 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15748 if (!SWIG_IsOK(ecode3)) {
15749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15750 }
15751 arg3 = static_cast< byte >(val3);
15752 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15753 if (!SWIG_IsOK(ecode4)) {
15754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15755 }
15756 arg4 = static_cast< byte >(val4);
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 (arg1)->SetMaskColour(arg2,arg3,arg4);
15760 wxPyEndAllowThreads(__tstate);
15761 if (PyErr_Occurred()) SWIG_fail;
15762 }
15763 resultobj = SWIG_Py_Void();
15764 return resultobj;
15765 fail:
15766 return NULL;
15767 }
15768
15769
15770 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15771 PyObject *resultobj = 0;
15772 wxImage *arg1 = (wxImage *) 0 ;
15773 byte *arg2 = (byte *) 0 ;
15774 byte *arg3 = (byte *) 0 ;
15775 byte *arg4 = (byte *) 0 ;
15776 void *argp1 = 0 ;
15777 int res1 = 0 ;
15778 byte temp2 ;
15779 int res2 = SWIG_TMPOBJ ;
15780 byte temp3 ;
15781 int res3 = SWIG_TMPOBJ ;
15782 byte temp4 ;
15783 int res4 = SWIG_TMPOBJ ;
15784 PyObject *swig_obj[1] ;
15785
15786 arg2 = &temp2;
15787 arg3 = &temp3;
15788 arg4 = &temp4;
15789 if (!args) SWIG_fail;
15790 swig_obj[0] = args;
15791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15792 if (!SWIG_IsOK(res1)) {
15793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15794 }
15795 arg1 = reinterpret_cast< wxImage * >(argp1);
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 resultobj = SWIG_Py_Void();
15803 if (SWIG_IsTmpObj(res2)) {
15804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15805 } else {
15806 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15808 }
15809 if (SWIG_IsTmpObj(res3)) {
15810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15811 } else {
15812 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15814 }
15815 if (SWIG_IsTmpObj(res4)) {
15816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15817 } else {
15818 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15820 }
15821 return resultobj;
15822 fail:
15823 return NULL;
15824 }
15825
15826
15827 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15828 PyObject *resultobj = 0;
15829 wxImage *arg1 = (wxImage *) 0 ;
15830 byte result;
15831 void *argp1 = 0 ;
15832 int res1 = 0 ;
15833 PyObject *swig_obj[1] ;
15834
15835 if (!args) SWIG_fail;
15836 swig_obj[0] = args;
15837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15838 if (!SWIG_IsOK(res1)) {
15839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15840 }
15841 arg1 = reinterpret_cast< wxImage * >(argp1);
15842 {
15843 PyThreadState* __tstate = wxPyBeginAllowThreads();
15844 result = (byte)(arg1)->GetMaskRed();
15845 wxPyEndAllowThreads(__tstate);
15846 if (PyErr_Occurred()) SWIG_fail;
15847 }
15848 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15849 return resultobj;
15850 fail:
15851 return NULL;
15852 }
15853
15854
15855 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15856 PyObject *resultobj = 0;
15857 wxImage *arg1 = (wxImage *) 0 ;
15858 byte result;
15859 void *argp1 = 0 ;
15860 int res1 = 0 ;
15861 PyObject *swig_obj[1] ;
15862
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_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15868 }
15869 arg1 = reinterpret_cast< wxImage * >(argp1);
15870 {
15871 PyThreadState* __tstate = wxPyBeginAllowThreads();
15872 result = (byte)(arg1)->GetMaskGreen();
15873 wxPyEndAllowThreads(__tstate);
15874 if (PyErr_Occurred()) SWIG_fail;
15875 }
15876 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15877 return resultobj;
15878 fail:
15879 return NULL;
15880 }
15881
15882
15883 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15884 PyObject *resultobj = 0;
15885 wxImage *arg1 = (wxImage *) 0 ;
15886 byte result;
15887 void *argp1 = 0 ;
15888 int res1 = 0 ;
15889 PyObject *swig_obj[1] ;
15890
15891 if (!args) SWIG_fail;
15892 swig_obj[0] = args;
15893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15894 if (!SWIG_IsOK(res1)) {
15895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15896 }
15897 arg1 = reinterpret_cast< wxImage * >(argp1);
15898 {
15899 PyThreadState* __tstate = wxPyBeginAllowThreads();
15900 result = (byte)(arg1)->GetMaskBlue();
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj = 0;
15913 wxImage *arg1 = (wxImage *) 0 ;
15914 bool arg2 = (bool) true ;
15915 void *argp1 = 0 ;
15916 int res1 = 0 ;
15917 bool val2 ;
15918 int ecode2 = 0 ;
15919 PyObject * obj0 = 0 ;
15920 PyObject * obj1 = 0 ;
15921 char * kwnames[] = {
15922 (char *) "self",(char *) "mask", NULL
15923 };
15924
15925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15927 if (!SWIG_IsOK(res1)) {
15928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15929 }
15930 arg1 = reinterpret_cast< wxImage * >(argp1);
15931 if (obj1) {
15932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15933 if (!SWIG_IsOK(ecode2)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15935 }
15936 arg2 = static_cast< bool >(val2);
15937 }
15938 {
15939 PyThreadState* __tstate = wxPyBeginAllowThreads();
15940 (arg1)->SetMask(arg2);
15941 wxPyEndAllowThreads(__tstate);
15942 if (PyErr_Occurred()) SWIG_fail;
15943 }
15944 resultobj = SWIG_Py_Void();
15945 return resultobj;
15946 fail:
15947 return NULL;
15948 }
15949
15950
15951 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15952 PyObject *resultobj = 0;
15953 wxImage *arg1 = (wxImage *) 0 ;
15954 bool result;
15955 void *argp1 = 0 ;
15956 int res1 = 0 ;
15957 PyObject *swig_obj[1] ;
15958
15959 if (!args) SWIG_fail;
15960 swig_obj[0] = args;
15961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15962 if (!SWIG_IsOK(res1)) {
15963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15964 }
15965 arg1 = reinterpret_cast< wxImage * >(argp1);
15966 {
15967 PyThreadState* __tstate = wxPyBeginAllowThreads();
15968 result = (bool)(arg1)->HasMask();
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 {
15973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15974 }
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15982 PyObject *resultobj = 0;
15983 wxImage *arg1 = (wxImage *) 0 ;
15984 double arg2 ;
15985 wxPoint *arg3 = 0 ;
15986 bool arg4 = (bool) true ;
15987 wxPoint *arg5 = (wxPoint *) NULL ;
15988 SwigValueWrapper<wxImage > result;
15989 void *argp1 = 0 ;
15990 int res1 = 0 ;
15991 double val2 ;
15992 int ecode2 = 0 ;
15993 wxPoint temp3 ;
15994 bool val4 ;
15995 int ecode4 = 0 ;
15996 void *argp5 = 0 ;
15997 int res5 = 0 ;
15998 PyObject * obj0 = 0 ;
15999 PyObject * obj1 = 0 ;
16000 PyObject * obj2 = 0 ;
16001 PyObject * obj3 = 0 ;
16002 PyObject * obj4 = 0 ;
16003 char * kwnames[] = {
16004 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16005 };
16006
16007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16011 }
16012 arg1 = reinterpret_cast< wxImage * >(argp1);
16013 ecode2 = SWIG_AsVal_double(obj1, &val2);
16014 if (!SWIG_IsOK(ecode2)) {
16015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16016 }
16017 arg2 = static_cast< double >(val2);
16018 {
16019 arg3 = &temp3;
16020 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16021 }
16022 if (obj3) {
16023 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16024 if (!SWIG_IsOK(ecode4)) {
16025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16026 }
16027 arg4 = static_cast< bool >(val4);
16028 }
16029 if (obj4) {
16030 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16031 if (!SWIG_IsOK(res5)) {
16032 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16033 }
16034 arg5 = reinterpret_cast< wxPoint * >(argp5);
16035 }
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16050 PyObject *resultobj = 0;
16051 wxImage *arg1 = (wxImage *) 0 ;
16052 bool arg2 = (bool) true ;
16053 SwigValueWrapper<wxImage > result;
16054 void *argp1 = 0 ;
16055 int res1 = 0 ;
16056 bool val2 ;
16057 int ecode2 = 0 ;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 char * kwnames[] = {
16061 (char *) "self",(char *) "clockwise", NULL
16062 };
16063
16064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16066 if (!SWIG_IsOK(res1)) {
16067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16068 }
16069 arg1 = reinterpret_cast< wxImage * >(argp1);
16070 if (obj1) {
16071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16072 if (!SWIG_IsOK(ecode2)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16074 }
16075 arg2 = static_cast< bool >(val2);
16076 }
16077 {
16078 PyThreadState* __tstate = wxPyBeginAllowThreads();
16079 result = (arg1)->Rotate90(arg2);
16080 wxPyEndAllowThreads(__tstate);
16081 if (PyErr_Occurred()) SWIG_fail;
16082 }
16083 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16084 return resultobj;
16085 fail:
16086 return NULL;
16087 }
16088
16089
16090 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16091 PyObject *resultobj = 0;
16092 wxImage *arg1 = (wxImage *) 0 ;
16093 bool arg2 = (bool) true ;
16094 SwigValueWrapper<wxImage > result;
16095 void *argp1 = 0 ;
16096 int res1 = 0 ;
16097 bool val2 ;
16098 int ecode2 = 0 ;
16099 PyObject * obj0 = 0 ;
16100 PyObject * obj1 = 0 ;
16101 char * kwnames[] = {
16102 (char *) "self",(char *) "horizontally", NULL
16103 };
16104
16105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16107 if (!SWIG_IsOK(res1)) {
16108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16109 }
16110 arg1 = reinterpret_cast< wxImage * >(argp1);
16111 if (obj1) {
16112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16113 if (!SWIG_IsOK(ecode2)) {
16114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16115 }
16116 arg2 = static_cast< bool >(val2);
16117 }
16118 {
16119 PyThreadState* __tstate = wxPyBeginAllowThreads();
16120 result = (arg1)->Mirror(arg2);
16121 wxPyEndAllowThreads(__tstate);
16122 if (PyErr_Occurred()) SWIG_fail;
16123 }
16124 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16125 return resultobj;
16126 fail:
16127 return NULL;
16128 }
16129
16130
16131 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16132 PyObject *resultobj = 0;
16133 wxImage *arg1 = (wxImage *) 0 ;
16134 byte arg2 ;
16135 byte arg3 ;
16136 byte arg4 ;
16137 byte arg5 ;
16138 byte arg6 ;
16139 byte arg7 ;
16140 void *argp1 = 0 ;
16141 int res1 = 0 ;
16142 unsigned char val2 ;
16143 int ecode2 = 0 ;
16144 unsigned char val3 ;
16145 int ecode3 = 0 ;
16146 unsigned char val4 ;
16147 int ecode4 = 0 ;
16148 unsigned char val5 ;
16149 int ecode5 = 0 ;
16150 unsigned char val6 ;
16151 int ecode6 = 0 ;
16152 unsigned char val7 ;
16153 int ecode7 = 0 ;
16154 PyObject * obj0 = 0 ;
16155 PyObject * obj1 = 0 ;
16156 PyObject * obj2 = 0 ;
16157 PyObject * obj3 = 0 ;
16158 PyObject * obj4 = 0 ;
16159 PyObject * obj5 = 0 ;
16160 PyObject * obj6 = 0 ;
16161 char * kwnames[] = {
16162 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16163 };
16164
16165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16167 if (!SWIG_IsOK(res1)) {
16168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16169 }
16170 arg1 = reinterpret_cast< wxImage * >(argp1);
16171 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16172 if (!SWIG_IsOK(ecode2)) {
16173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16174 }
16175 arg2 = static_cast< byte >(val2);
16176 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16177 if (!SWIG_IsOK(ecode3)) {
16178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16179 }
16180 arg3 = static_cast< byte >(val3);
16181 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16182 if (!SWIG_IsOK(ecode4)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16184 }
16185 arg4 = static_cast< byte >(val4);
16186 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16187 if (!SWIG_IsOK(ecode5)) {
16188 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16189 }
16190 arg5 = static_cast< byte >(val5);
16191 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16192 if (!SWIG_IsOK(ecode6)) {
16193 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16194 }
16195 arg6 = static_cast< byte >(val6);
16196 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16197 if (!SWIG_IsOK(ecode7)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16199 }
16200 arg7 = static_cast< byte >(val7);
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 resultobj = SWIG_Py_Void();
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16215 PyObject *resultobj = 0;
16216 wxImage *arg1 = (wxImage *) 0 ;
16217 double arg2 = (double) 0.299 ;
16218 double arg3 = (double) 0.587 ;
16219 double arg4 = (double) 0.114 ;
16220 SwigValueWrapper<wxImage > result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 double val2 ;
16224 int ecode2 = 0 ;
16225 double val3 ;
16226 int ecode3 = 0 ;
16227 double val4 ;
16228 int ecode4 = 0 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 PyObject * obj3 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 if (obj1) {
16244 ecode2 = SWIG_AsVal_double(obj1, &val2);
16245 if (!SWIG_IsOK(ecode2)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16247 }
16248 arg2 = static_cast< double >(val2);
16249 }
16250 if (obj2) {
16251 ecode3 = SWIG_AsVal_double(obj2, &val3);
16252 if (!SWIG_IsOK(ecode3)) {
16253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16254 }
16255 arg3 = static_cast< double >(val3);
16256 }
16257 if (obj3) {
16258 ecode4 = SWIG_AsVal_double(obj3, &val4);
16259 if (!SWIG_IsOK(ecode4)) {
16260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16261 }
16262 arg4 = static_cast< double >(val4);
16263 }
16264 {
16265 PyThreadState* __tstate = wxPyBeginAllowThreads();
16266 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16267 wxPyEndAllowThreads(__tstate);
16268 if (PyErr_Occurred()) SWIG_fail;
16269 }
16270 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16271 return resultobj;
16272 fail:
16273 return NULL;
16274 }
16275
16276
16277 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16278 PyObject *resultobj = 0;
16279 wxImage *arg1 = (wxImage *) 0 ;
16280 byte arg2 ;
16281 byte arg3 ;
16282 byte arg4 ;
16283 SwigValueWrapper<wxImage > result;
16284 void *argp1 = 0 ;
16285 int res1 = 0 ;
16286 unsigned char val2 ;
16287 int ecode2 = 0 ;
16288 unsigned char val3 ;
16289 int ecode3 = 0 ;
16290 unsigned char val4 ;
16291 int ecode4 = 0 ;
16292 PyObject * obj0 = 0 ;
16293 PyObject * obj1 = 0 ;
16294 PyObject * obj2 = 0 ;
16295 PyObject * obj3 = 0 ;
16296 char * kwnames[] = {
16297 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16298 };
16299
16300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16302 if (!SWIG_IsOK(res1)) {
16303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16304 }
16305 arg1 = reinterpret_cast< wxImage * >(argp1);
16306 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16307 if (!SWIG_IsOK(ecode2)) {
16308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16309 }
16310 arg2 = static_cast< byte >(val2);
16311 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16312 if (!SWIG_IsOK(ecode3)) {
16313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16314 }
16315 arg3 = static_cast< byte >(val3);
16316 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16317 if (!SWIG_IsOK(ecode4)) {
16318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16319 }
16320 arg4 = static_cast< byte >(val4);
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16324 wxPyEndAllowThreads(__tstate);
16325 if (PyErr_Occurred()) SWIG_fail;
16326 }
16327 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16328 return resultobj;
16329 fail:
16330 return NULL;
16331 }
16332
16333
16334 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16335 PyObject *resultobj = 0;
16336 wxImage *arg1 = (wxImage *) 0 ;
16337 wxString *arg2 = 0 ;
16338 wxString *arg3 = 0 ;
16339 void *argp1 = 0 ;
16340 int res1 = 0 ;
16341 bool temp2 = false ;
16342 bool temp3 = false ;
16343 PyObject * obj0 = 0 ;
16344 PyObject * obj1 = 0 ;
16345 PyObject * obj2 = 0 ;
16346 char * kwnames[] = {
16347 (char *) "self",(char *) "name",(char *) "value", NULL
16348 };
16349
16350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16354 }
16355 arg1 = reinterpret_cast< wxImage * >(argp1);
16356 {
16357 arg2 = wxString_in_helper(obj1);
16358 if (arg2 == NULL) SWIG_fail;
16359 temp2 = true;
16360 }
16361 {
16362 arg3 = wxString_in_helper(obj2);
16363 if (arg3 == NULL) SWIG_fail;
16364 temp3 = true;
16365 }
16366 {
16367 PyThreadState* __tstate = wxPyBeginAllowThreads();
16368 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 resultobj = SWIG_Py_Void();
16373 {
16374 if (temp2)
16375 delete arg2;
16376 }
16377 {
16378 if (temp3)
16379 delete arg3;
16380 }
16381 return resultobj;
16382 fail:
16383 {
16384 if (temp2)
16385 delete arg2;
16386 }
16387 {
16388 if (temp3)
16389 delete arg3;
16390 }
16391 return NULL;
16392 }
16393
16394
16395 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj = 0;
16397 wxImage *arg1 = (wxImage *) 0 ;
16398 wxString *arg2 = 0 ;
16399 int arg3 ;
16400 void *argp1 = 0 ;
16401 int res1 = 0 ;
16402 bool temp2 = false ;
16403 int val3 ;
16404 int ecode3 = 0 ;
16405 PyObject * obj0 = 0 ;
16406 PyObject * obj1 = 0 ;
16407 PyObject * obj2 = 0 ;
16408 char * kwnames[] = {
16409 (char *) "self",(char *) "name",(char *) "value", NULL
16410 };
16411
16412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16414 if (!SWIG_IsOK(res1)) {
16415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16416 }
16417 arg1 = reinterpret_cast< wxImage * >(argp1);
16418 {
16419 arg2 = wxString_in_helper(obj1);
16420 if (arg2 == NULL) SWIG_fail;
16421 temp2 = true;
16422 }
16423 ecode3 = SWIG_AsVal_int(obj2, &val3);
16424 if (!SWIG_IsOK(ecode3)) {
16425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16426 }
16427 arg3 = static_cast< int >(val3);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 (arg1)->SetOption((wxString const &)*arg2,arg3);
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 resultobj = SWIG_Py_Void();
16435 {
16436 if (temp2)
16437 delete arg2;
16438 }
16439 return resultobj;
16440 fail:
16441 {
16442 if (temp2)
16443 delete arg2;
16444 }
16445 return NULL;
16446 }
16447
16448
16449 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj = 0;
16451 wxImage *arg1 = (wxImage *) 0 ;
16452 wxString *arg2 = 0 ;
16453 wxString result;
16454 void *argp1 = 0 ;
16455 int res1 = 0 ;
16456 bool temp2 = false ;
16457 PyObject * obj0 = 0 ;
16458 PyObject * obj1 = 0 ;
16459 char * kwnames[] = {
16460 (char *) "self",(char *) "name", NULL
16461 };
16462
16463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16465 if (!SWIG_IsOK(res1)) {
16466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16467 }
16468 arg1 = reinterpret_cast< wxImage * >(argp1);
16469 {
16470 arg2 = wxString_in_helper(obj1);
16471 if (arg2 == NULL) SWIG_fail;
16472 temp2 = true;
16473 }
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16477 wxPyEndAllowThreads(__tstate);
16478 if (PyErr_Occurred()) SWIG_fail;
16479 }
16480 {
16481 #if wxUSE_UNICODE
16482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16483 #else
16484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16485 #endif
16486 }
16487 {
16488 if (temp2)
16489 delete arg2;
16490 }
16491 return resultobj;
16492 fail:
16493 {
16494 if (temp2)
16495 delete arg2;
16496 }
16497 return NULL;
16498 }
16499
16500
16501 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16502 PyObject *resultobj = 0;
16503 wxImage *arg1 = (wxImage *) 0 ;
16504 wxString *arg2 = 0 ;
16505 int result;
16506 void *argp1 = 0 ;
16507 int res1 = 0 ;
16508 bool temp2 = false ;
16509 PyObject * obj0 = 0 ;
16510 PyObject * obj1 = 0 ;
16511 char * kwnames[] = {
16512 (char *) "self",(char *) "name", NULL
16513 };
16514
16515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16517 if (!SWIG_IsOK(res1)) {
16518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16519 }
16520 arg1 = reinterpret_cast< wxImage * >(argp1);
16521 {
16522 arg2 = wxString_in_helper(obj1);
16523 if (arg2 == NULL) SWIG_fail;
16524 temp2 = true;
16525 }
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16529 wxPyEndAllowThreads(__tstate);
16530 if (PyErr_Occurred()) SWIG_fail;
16531 }
16532 resultobj = SWIG_From_int(static_cast< int >(result));
16533 {
16534 if (temp2)
16535 delete arg2;
16536 }
16537 return resultobj;
16538 fail:
16539 {
16540 if (temp2)
16541 delete arg2;
16542 }
16543 return NULL;
16544 }
16545
16546
16547 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16548 PyObject *resultobj = 0;
16549 wxImage *arg1 = (wxImage *) 0 ;
16550 wxString *arg2 = 0 ;
16551 bool result;
16552 void *argp1 = 0 ;
16553 int res1 = 0 ;
16554 bool temp2 = false ;
16555 PyObject * obj0 = 0 ;
16556 PyObject * obj1 = 0 ;
16557 char * kwnames[] = {
16558 (char *) "self",(char *) "name", NULL
16559 };
16560
16561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16563 if (!SWIG_IsOK(res1)) {
16564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16565 }
16566 arg1 = reinterpret_cast< wxImage * >(argp1);
16567 {
16568 arg2 = wxString_in_helper(obj1);
16569 if (arg2 == NULL) SWIG_fail;
16570 temp2 = true;
16571 }
16572 {
16573 PyThreadState* __tstate = wxPyBeginAllowThreads();
16574 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 {
16579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16580 }
16581 {
16582 if (temp2)
16583 delete arg2;
16584 }
16585 return resultobj;
16586 fail:
16587 {
16588 if (temp2)
16589 delete arg2;
16590 }
16591 return NULL;
16592 }
16593
16594
16595 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16596 PyObject *resultobj = 0;
16597 wxImage *arg1 = (wxImage *) 0 ;
16598 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16599 unsigned long result;
16600 void *argp1 = 0 ;
16601 int res1 = 0 ;
16602 unsigned long val2 ;
16603 int ecode2 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 char * kwnames[] = {
16607 (char *) "self",(char *) "stopafter", NULL
16608 };
16609
16610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16612 if (!SWIG_IsOK(res1)) {
16613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16614 }
16615 arg1 = reinterpret_cast< wxImage * >(argp1);
16616 if (obj1) {
16617 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16618 if (!SWIG_IsOK(ecode2)) {
16619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16620 }
16621 arg2 = static_cast< unsigned long >(val2);
16622 }
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 result = (unsigned long)(arg1)->CountColours(arg2);
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj = 0;
16638 wxImage *arg1 = (wxImage *) 0 ;
16639 wxImageHistogram *arg2 = 0 ;
16640 unsigned long result;
16641 void *argp1 = 0 ;
16642 int res1 = 0 ;
16643 void *argp2 = 0 ;
16644 int res2 = 0 ;
16645 PyObject * obj0 = 0 ;
16646 PyObject * obj1 = 0 ;
16647 char * kwnames[] = {
16648 (char *) "self",(char *) "h", NULL
16649 };
16650
16651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16653 if (!SWIG_IsOK(res1)) {
16654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16655 }
16656 arg1 = reinterpret_cast< wxImage * >(argp1);
16657 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16658 if (!SWIG_IsOK(res2)) {
16659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16660 }
16661 if (!argp2) {
16662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16663 }
16664 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16665 {
16666 PyThreadState* __tstate = wxPyBeginAllowThreads();
16667 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16668 wxPyEndAllowThreads(__tstate);
16669 if (PyErr_Occurred()) SWIG_fail;
16670 }
16671 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj = 0;
16680 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16681 void *argp1 = 0 ;
16682 int res1 = 0 ;
16683 PyObject * obj0 = 0 ;
16684 char * kwnames[] = {
16685 (char *) "handler", NULL
16686 };
16687
16688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16690 if (!SWIG_IsOK(res1)) {
16691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16692 }
16693 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16694 {
16695 PyThreadState* __tstate = wxPyBeginAllowThreads();
16696 wxImage::AddHandler(arg1);
16697 wxPyEndAllowThreads(__tstate);
16698 if (PyErr_Occurred()) SWIG_fail;
16699 }
16700 resultobj = SWIG_Py_Void();
16701 return resultobj;
16702 fail:
16703 return NULL;
16704 }
16705
16706
16707 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16708 PyObject *resultobj = 0;
16709 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16710 void *argp1 = 0 ;
16711 int res1 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 char * kwnames[] = {
16714 (char *) "handler", NULL
16715 };
16716
16717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16719 if (!SWIG_IsOK(res1)) {
16720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16721 }
16722 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16723 {
16724 PyThreadState* __tstate = wxPyBeginAllowThreads();
16725 wxImage::InsertHandler(arg1);
16726 wxPyEndAllowThreads(__tstate);
16727 if (PyErr_Occurred()) SWIG_fail;
16728 }
16729 resultobj = SWIG_Py_Void();
16730 return resultobj;
16731 fail:
16732 return NULL;
16733 }
16734
16735
16736 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16737 PyObject *resultobj = 0;
16738 wxString *arg1 = 0 ;
16739 bool result;
16740 bool temp1 = false ;
16741 PyObject * obj0 = 0 ;
16742 char * kwnames[] = {
16743 (char *) "name", NULL
16744 };
16745
16746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16747 {
16748 arg1 = wxString_in_helper(obj0);
16749 if (arg1 == NULL) SWIG_fail;
16750 temp1 = true;
16751 }
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 {
16759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16760 }
16761 {
16762 if (temp1)
16763 delete arg1;
16764 }
16765 return resultobj;
16766 fail:
16767 {
16768 if (temp1)
16769 delete arg1;
16770 }
16771 return NULL;
16772 }
16773
16774
16775 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16776 PyObject *resultobj = 0;
16777 PyObject *result = 0 ;
16778
16779 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16780 {
16781 PyThreadState* __tstate = wxPyBeginAllowThreads();
16782 result = (PyObject *)wxImage_GetHandlers();
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 resultobj = result;
16787 return resultobj;
16788 fail:
16789 return NULL;
16790 }
16791
16792
16793 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16794 PyObject *resultobj = 0;
16795 wxString result;
16796
16797 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16798 {
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 result = wxImage::GetImageExtWildcard();
16801 wxPyEndAllowThreads(__tstate);
16802 if (PyErr_Occurred()) SWIG_fail;
16803 }
16804 {
16805 #if wxUSE_UNICODE
16806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16807 #else
16808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16809 #endif
16810 }
16811 return resultobj;
16812 fail:
16813 return NULL;
16814 }
16815
16816
16817 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj = 0;
16819 wxImage *arg1 = (wxImage *) 0 ;
16820 int arg2 = (int) -1 ;
16821 wxBitmap result;
16822 void *argp1 = 0 ;
16823 int res1 = 0 ;
16824 int val2 ;
16825 int ecode2 = 0 ;
16826 PyObject * obj0 = 0 ;
16827 PyObject * obj1 = 0 ;
16828 char * kwnames[] = {
16829 (char *) "self",(char *) "depth", NULL
16830 };
16831
16832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16834 if (!SWIG_IsOK(res1)) {
16835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16836 }
16837 arg1 = reinterpret_cast< wxImage * >(argp1);
16838 if (obj1) {
16839 ecode2 = SWIG_AsVal_int(obj1, &val2);
16840 if (!SWIG_IsOK(ecode2)) {
16841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16842 }
16843 arg2 = static_cast< int >(val2);
16844 }
16845 {
16846 if (!wxPyCheckForApp()) SWIG_fail;
16847 PyThreadState* __tstate = wxPyBeginAllowThreads();
16848 result = wxImage_ConvertToBitmap(arg1,arg2);
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16853 return resultobj;
16854 fail:
16855 return NULL;
16856 }
16857
16858
16859 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16860 PyObject *resultobj = 0;
16861 wxImage *arg1 = (wxImage *) 0 ;
16862 byte arg2 ;
16863 byte arg3 ;
16864 byte arg4 ;
16865 wxBitmap result;
16866 void *argp1 = 0 ;
16867 int res1 = 0 ;
16868 unsigned char val2 ;
16869 int ecode2 = 0 ;
16870 unsigned char val3 ;
16871 int ecode3 = 0 ;
16872 unsigned char val4 ;
16873 int ecode4 = 0 ;
16874 PyObject * obj0 = 0 ;
16875 PyObject * obj1 = 0 ;
16876 PyObject * obj2 = 0 ;
16877 PyObject * obj3 = 0 ;
16878 char * kwnames[] = {
16879 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16880 };
16881
16882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16884 if (!SWIG_IsOK(res1)) {
16885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16886 }
16887 arg1 = reinterpret_cast< wxImage * >(argp1);
16888 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16889 if (!SWIG_IsOK(ecode2)) {
16890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16891 }
16892 arg2 = static_cast< byte >(val2);
16893 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16894 if (!SWIG_IsOK(ecode3)) {
16895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16896 }
16897 arg3 = static_cast< byte >(val3);
16898 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16899 if (!SWIG_IsOK(ecode4)) {
16900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16901 }
16902 arg4 = static_cast< byte >(val4);
16903 {
16904 if (!wxPyCheckForApp()) SWIG_fail;
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj = 0;
16919 wxImage *arg1 = (wxImage *) 0 ;
16920 double arg2 ;
16921 void *argp1 = 0 ;
16922 int res1 = 0 ;
16923 double val2 ;
16924 int ecode2 = 0 ;
16925 PyObject * obj0 = 0 ;
16926 PyObject * obj1 = 0 ;
16927 char * kwnames[] = {
16928 (char *) "self",(char *) "angle", NULL
16929 };
16930
16931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16933 if (!SWIG_IsOK(res1)) {
16934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16935 }
16936 arg1 = reinterpret_cast< wxImage * >(argp1);
16937 ecode2 = SWIG_AsVal_double(obj1, &val2);
16938 if (!SWIG_IsOK(ecode2)) {
16939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16940 }
16941 arg2 = static_cast< double >(val2);
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 (arg1)->RotateHue(arg2);
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = SWIG_Py_Void();
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj = 0;
16957 wxImage_RGBValue arg1 ;
16958 wxImage_HSVValue result;
16959 void *argp1 ;
16960 int res1 = 0 ;
16961 PyObject * obj0 = 0 ;
16962 char * kwnames[] = {
16963 (char *) "rgb", NULL
16964 };
16965
16966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16967 {
16968 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16969 if (!SWIG_IsOK(res1)) {
16970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16971 }
16972 if (!argp1) {
16973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16974 } else {
16975 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16976 arg1 = *temp;
16977 if (SWIG_IsNewObj(res1)) delete temp;
16978 }
16979 }
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 result = wxImage::RGBtoHSV(arg1);
16983 wxPyEndAllowThreads(__tstate);
16984 if (PyErr_Occurred()) SWIG_fail;
16985 }
16986 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16987 return resultobj;
16988 fail:
16989 return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj = 0;
16995 wxImage_HSVValue arg1 ;
16996 wxImage_RGBValue result;
16997 void *argp1 ;
16998 int res1 = 0 ;
16999 PyObject * obj0 = 0 ;
17000 char * kwnames[] = {
17001 (char *) "hsv", NULL
17002 };
17003
17004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17005 {
17006 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17007 if (!SWIG_IsOK(res1)) {
17008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17009 }
17010 if (!argp1) {
17011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17012 } else {
17013 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17014 arg1 = *temp;
17015 if (SWIG_IsNewObj(res1)) delete temp;
17016 }
17017 }
17018 {
17019 PyThreadState* __tstate = wxPyBeginAllowThreads();
17020 result = wxImage::HSVtoRGB(arg1);
17021 wxPyEndAllowThreads(__tstate);
17022 if (PyErr_Occurred()) SWIG_fail;
17023 }
17024 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17025 return resultobj;
17026 fail:
17027 return NULL;
17028 }
17029
17030
17031 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17032 PyObject *obj;
17033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17034 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17035 return SWIG_Py_Void();
17036 }
17037
17038 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17039 return SWIG_Python_InitShadowInstance(args);
17040 }
17041
17042 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj = 0;
17044 int arg1 ;
17045 int arg2 ;
17046 buffer arg3 ;
17047 int arg4 ;
17048 buffer arg5 = (buffer) NULL ;
17049 int arg6 = (int) 0 ;
17050 wxImage *result = 0 ;
17051 int val1 ;
17052 int ecode1 = 0 ;
17053 int val2 ;
17054 int ecode2 = 0 ;
17055 Py_ssize_t temp3 ;
17056 Py_ssize_t temp5 ;
17057 PyObject * obj0 = 0 ;
17058 PyObject * obj1 = 0 ;
17059 PyObject * obj2 = 0 ;
17060 PyObject * obj3 = 0 ;
17061 char * kwnames[] = {
17062 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17063 };
17064
17065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17066 ecode1 = SWIG_AsVal_int(obj0, &val1);
17067 if (!SWIG_IsOK(ecode1)) {
17068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17069 }
17070 arg1 = static_cast< int >(val1);
17071 ecode2 = SWIG_AsVal_int(obj1, &val2);
17072 if (!SWIG_IsOK(ecode2)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17074 }
17075 arg2 = static_cast< int >(val2);
17076 {
17077 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17078 arg4 = (int)temp3;
17079 }
17080 if (obj3) {
17081 {
17082 if (obj3 != Py_None) {
17083 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17084 arg6 = (int)temp5;
17085 }
17086 }
17087 }
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17091 wxPyEndAllowThreads(__tstate);
17092 if (PyErr_Occurred()) SWIG_fail;
17093 }
17094 {
17095 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17096 }
17097 return resultobj;
17098 fail:
17099 return NULL;
17100 }
17101
17102
17103 SWIGINTERN int NullImage_set(PyObject *) {
17104 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17105 return 1;
17106 }
17107
17108
17109 SWIGINTERN PyObject *NullImage_get(void) {
17110 PyObject *pyobj = 0;
17111
17112 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17113 return pyobj;
17114 }
17115
17116
17117 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17118 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17119 return 1;
17120 }
17121
17122
17123 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17124 PyObject *pyobj = 0;
17125
17126 {
17127 #if wxUSE_UNICODE
17128 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17129 #else
17130 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17131 #endif
17132 }
17133 return pyobj;
17134 }
17135
17136
17137 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17138 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17139 return 1;
17140 }
17141
17142
17143 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17144 PyObject *pyobj = 0;
17145
17146 {
17147 #if wxUSE_UNICODE
17148 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17149 #else
17150 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17151 #endif
17152 }
17153 return pyobj;
17154 }
17155
17156
17157 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17158 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17159 return 1;
17160 }
17161
17162
17163 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17164 PyObject *pyobj = 0;
17165
17166 {
17167 #if wxUSE_UNICODE
17168 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17169 #else
17170 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17171 #endif
17172 }
17173 return pyobj;
17174 }
17175
17176
17177 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17178 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17179 return 1;
17180 }
17181
17182
17183 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17184 PyObject *pyobj = 0;
17185
17186 {
17187 #if wxUSE_UNICODE
17188 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17189 #else
17190 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17191 #endif
17192 }
17193 return pyobj;
17194 }
17195
17196
17197 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17198 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17199 return 1;
17200 }
17201
17202
17203 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17204 PyObject *pyobj = 0;
17205
17206 {
17207 #if wxUSE_UNICODE
17208 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17209 #else
17210 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17211 #endif
17212 }
17213 return pyobj;
17214 }
17215
17216
17217 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17218 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17219 return 1;
17220 }
17221
17222
17223 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17224 PyObject *pyobj = 0;
17225
17226 {
17227 #if wxUSE_UNICODE
17228 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17229 #else
17230 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17231 #endif
17232 }
17233 return pyobj;
17234 }
17235
17236
17237 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17238 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17239 return 1;
17240 }
17241
17242
17243 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17244 PyObject *pyobj = 0;
17245
17246 {
17247 #if wxUSE_UNICODE
17248 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17249 #else
17250 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17251 #endif
17252 }
17253 return pyobj;
17254 }
17255
17256
17257 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17258 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17259 return 1;
17260 }
17261
17262
17263 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17264 PyObject *pyobj = 0;
17265
17266 {
17267 #if wxUSE_UNICODE
17268 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17269 #else
17270 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17271 #endif
17272 }
17273 return pyobj;
17274 }
17275
17276
17277 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17278 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17279 return 1;
17280 }
17281
17282
17283 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17284 PyObject *pyobj = 0;
17285
17286 {
17287 #if wxUSE_UNICODE
17288 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17289 #else
17290 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17291 #endif
17292 }
17293 return pyobj;
17294 }
17295
17296
17297 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17298 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17299 return 1;
17300 }
17301
17302
17303 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17304 PyObject *pyobj = 0;
17305
17306 {
17307 #if wxUSE_UNICODE
17308 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17309 #else
17310 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17311 #endif
17312 }
17313 return pyobj;
17314 }
17315
17316
17317 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17318 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17319 return 1;
17320 }
17321
17322
17323 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17324 PyObject *pyobj = 0;
17325
17326 {
17327 #if wxUSE_UNICODE
17328 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17329 #else
17330 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17331 #endif
17332 }
17333 return pyobj;
17334 }
17335
17336
17337 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17338 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17339 return 1;
17340 }
17341
17342
17343 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17344 PyObject *pyobj = 0;
17345
17346 {
17347 #if wxUSE_UNICODE
17348 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17349 #else
17350 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17351 #endif
17352 }
17353 return pyobj;
17354 }
17355
17356
17357 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17358 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17359 return 1;
17360 }
17361
17362
17363 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17364 PyObject *pyobj = 0;
17365
17366 {
17367 #if wxUSE_UNICODE
17368 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17369 #else
17370 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17371 #endif
17372 }
17373 return pyobj;
17374 }
17375
17376
17377 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17378 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17379 return 1;
17380 }
17381
17382
17383 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17384 PyObject *pyobj = 0;
17385
17386 {
17387 #if wxUSE_UNICODE
17388 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17389 #else
17390 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17391 #endif
17392 }
17393 return pyobj;
17394 }
17395
17396
17397 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17398 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17399 return 1;
17400 }
17401
17402
17403 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17404 PyObject *pyobj = 0;
17405
17406 {
17407 #if wxUSE_UNICODE
17408 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17409 #else
17410 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17411 #endif
17412 }
17413 return pyobj;
17414 }
17415
17416
17417 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17418 PyObject *resultobj = 0;
17419 wxBMPHandler *result = 0 ;
17420
17421 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (wxBMPHandler *)new wxBMPHandler();
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17429 return resultobj;
17430 fail:
17431 return NULL;
17432 }
17433
17434
17435 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17436 PyObject *obj;
17437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17438 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17439 return SWIG_Py_Void();
17440 }
17441
17442 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 return SWIG_Python_InitShadowInstance(args);
17444 }
17445
17446 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17447 PyObject *resultobj = 0;
17448 wxICOHandler *result = 0 ;
17449
17450 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17451 {
17452 PyThreadState* __tstate = wxPyBeginAllowThreads();
17453 result = (wxICOHandler *)new wxICOHandler();
17454 wxPyEndAllowThreads(__tstate);
17455 if (PyErr_Occurred()) SWIG_fail;
17456 }
17457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17458 return resultobj;
17459 fail:
17460 return NULL;
17461 }
17462
17463
17464 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17465 PyObject *obj;
17466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17467 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17468 return SWIG_Py_Void();
17469 }
17470
17471 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17472 return SWIG_Python_InitShadowInstance(args);
17473 }
17474
17475 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 PyObject *resultobj = 0;
17477 wxCURHandler *result = 0 ;
17478
17479 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (wxCURHandler *)new wxCURHandler();
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17487 return resultobj;
17488 fail:
17489 return NULL;
17490 }
17491
17492
17493 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 PyObject *obj;
17495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17496 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17497 return SWIG_Py_Void();
17498 }
17499
17500 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17501 return SWIG_Python_InitShadowInstance(args);
17502 }
17503
17504 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17505 PyObject *resultobj = 0;
17506 wxANIHandler *result = 0 ;
17507
17508 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (wxANIHandler *)new wxANIHandler();
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17523 PyObject *obj;
17524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17525 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17526 return SWIG_Py_Void();
17527 }
17528
17529 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17530 return SWIG_Python_InitShadowInstance(args);
17531 }
17532
17533 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17534 PyObject *resultobj = 0;
17535 wxPNGHandler *result = 0 ;
17536
17537 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (wxPNGHandler *)new wxPNGHandler();
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17545 return resultobj;
17546 fail:
17547 return NULL;
17548 }
17549
17550
17551 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 PyObject *obj;
17553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17554 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17555 return SWIG_Py_Void();
17556 }
17557
17558 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559 return SWIG_Python_InitShadowInstance(args);
17560 }
17561
17562 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17563 PyObject *resultobj = 0;
17564 wxGIFHandler *result = 0 ;
17565
17566 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17567 {
17568 PyThreadState* __tstate = wxPyBeginAllowThreads();
17569 result = (wxGIFHandler *)new wxGIFHandler();
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17574 return resultobj;
17575 fail:
17576 return NULL;
17577 }
17578
17579
17580 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 PyObject *obj;
17582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17583 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17584 return SWIG_Py_Void();
17585 }
17586
17587 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17588 return SWIG_Python_InitShadowInstance(args);
17589 }
17590
17591 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *resultobj = 0;
17593 wxPCXHandler *result = 0 ;
17594
17595 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17596 {
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (wxPCXHandler *)new wxPCXHandler();
17599 wxPyEndAllowThreads(__tstate);
17600 if (PyErr_Occurred()) SWIG_fail;
17601 }
17602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 PyObject *obj;
17611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17612 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17613 return SWIG_Py_Void();
17614 }
17615
17616 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17617 return SWIG_Python_InitShadowInstance(args);
17618 }
17619
17620 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *resultobj = 0;
17622 wxJPEGHandler *result = 0 ;
17623
17624 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17625 {
17626 PyThreadState* __tstate = wxPyBeginAllowThreads();
17627 result = (wxJPEGHandler *)new wxJPEGHandler();
17628 wxPyEndAllowThreads(__tstate);
17629 if (PyErr_Occurred()) SWIG_fail;
17630 }
17631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *obj;
17640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17641 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17642 return SWIG_Py_Void();
17643 }
17644
17645 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17646 return SWIG_Python_InitShadowInstance(args);
17647 }
17648
17649 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17650 PyObject *resultobj = 0;
17651 wxPNMHandler *result = 0 ;
17652
17653 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17654 {
17655 PyThreadState* __tstate = wxPyBeginAllowThreads();
17656 result = (wxPNMHandler *)new wxPNMHandler();
17657 wxPyEndAllowThreads(__tstate);
17658 if (PyErr_Occurred()) SWIG_fail;
17659 }
17660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17668 PyObject *obj;
17669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17671 return SWIG_Py_Void();
17672 }
17673
17674 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17675 return SWIG_Python_InitShadowInstance(args);
17676 }
17677
17678 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17679 PyObject *resultobj = 0;
17680 wxXPMHandler *result = 0 ;
17681
17682 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = (wxXPMHandler *)new wxXPMHandler();
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17690 return resultobj;
17691 fail:
17692 return NULL;
17693 }
17694
17695
17696 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17697 PyObject *obj;
17698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17699 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17700 return SWIG_Py_Void();
17701 }
17702
17703 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17704 return SWIG_Python_InitShadowInstance(args);
17705 }
17706
17707 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17708 PyObject *resultobj = 0;
17709 wxTIFFHandler *result = 0 ;
17710
17711 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17712 {
17713 PyThreadState* __tstate = wxPyBeginAllowThreads();
17714 result = (wxTIFFHandler *)new wxTIFFHandler();
17715 wxPyEndAllowThreads(__tstate);
17716 if (PyErr_Occurred()) SWIG_fail;
17717 }
17718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17719 return resultobj;
17720 fail:
17721 return NULL;
17722 }
17723
17724
17725 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17726 PyObject *obj;
17727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17728 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17729 return SWIG_Py_Void();
17730 }
17731
17732 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17733 return SWIG_Python_InitShadowInstance(args);
17734 }
17735
17736 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17737 PyObject *resultobj = 0;
17738 wxImage *arg1 = 0 ;
17739 wxImage *arg2 = 0 ;
17740 int arg3 = (int) 236 ;
17741 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17742 bool result;
17743 void *argp1 = 0 ;
17744 int res1 = 0 ;
17745 void *argp2 = 0 ;
17746 int res2 = 0 ;
17747 int val3 ;
17748 int ecode3 = 0 ;
17749 int val4 ;
17750 int ecode4 = 0 ;
17751 PyObject * obj0 = 0 ;
17752 PyObject * obj1 = 0 ;
17753 PyObject * obj2 = 0 ;
17754 PyObject * obj3 = 0 ;
17755 char * kwnames[] = {
17756 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17757 };
17758
17759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17760 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17761 if (!SWIG_IsOK(res1)) {
17762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17763 }
17764 if (!argp1) {
17765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17766 }
17767 arg1 = reinterpret_cast< wxImage * >(argp1);
17768 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17769 if (!SWIG_IsOK(res2)) {
17770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17771 }
17772 if (!argp2) {
17773 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17774 }
17775 arg2 = reinterpret_cast< wxImage * >(argp2);
17776 if (obj2) {
17777 ecode3 = SWIG_AsVal_int(obj2, &val3);
17778 if (!SWIG_IsOK(ecode3)) {
17779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17780 }
17781 arg3 = static_cast< int >(val3);
17782 }
17783 if (obj3) {
17784 ecode4 = SWIG_AsVal_int(obj3, &val4);
17785 if (!SWIG_IsOK(ecode4)) {
17786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17787 }
17788 arg4 = static_cast< int >(val4);
17789 }
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 {
17797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17798 }
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17806 PyObject *obj;
17807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17808 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17809 return SWIG_Py_Void();
17810 }
17811
17812 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17813 PyObject *resultobj = 0;
17814 wxEvtHandler *result = 0 ;
17815
17816 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17817 {
17818 PyThreadState* __tstate = wxPyBeginAllowThreads();
17819 result = (wxEvtHandler *)new wxEvtHandler();
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17824 return resultobj;
17825 fail:
17826 return NULL;
17827 }
17828
17829
17830 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17831 PyObject *resultobj = 0;
17832 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17833 wxEvtHandler *result = 0 ;
17834 void *argp1 = 0 ;
17835 int res1 = 0 ;
17836 PyObject *swig_obj[1] ;
17837
17838 if (!args) SWIG_fail;
17839 swig_obj[0] = args;
17840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17841 if (!SWIG_IsOK(res1)) {
17842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17843 }
17844 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17845 {
17846 PyThreadState* __tstate = wxPyBeginAllowThreads();
17847 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 {
17852 resultobj = wxPyMake_wxObject(result, 0);
17853 }
17854 return resultobj;
17855 fail:
17856 return NULL;
17857 }
17858
17859
17860 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17861 PyObject *resultobj = 0;
17862 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17863 wxEvtHandler *result = 0 ;
17864 void *argp1 = 0 ;
17865 int res1 = 0 ;
17866 PyObject *swig_obj[1] ;
17867
17868 if (!args) SWIG_fail;
17869 swig_obj[0] = args;
17870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17871 if (!SWIG_IsOK(res1)) {
17872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17873 }
17874 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17875 {
17876 PyThreadState* __tstate = wxPyBeginAllowThreads();
17877 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 {
17882 resultobj = wxPyMake_wxObject(result, 0);
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj = 0;
17892 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17893 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17894 void *argp1 = 0 ;
17895 int res1 = 0 ;
17896 void *argp2 = 0 ;
17897 int res2 = 0 ;
17898 PyObject * obj0 = 0 ;
17899 PyObject * obj1 = 0 ;
17900 char * kwnames[] = {
17901 (char *) "self",(char *) "handler", NULL
17902 };
17903
17904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17906 if (!SWIG_IsOK(res1)) {
17907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17908 }
17909 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17911 if (!SWIG_IsOK(res2)) {
17912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17913 }
17914 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17915 {
17916 PyThreadState* __tstate = wxPyBeginAllowThreads();
17917 (arg1)->SetNextHandler(arg2);
17918 wxPyEndAllowThreads(__tstate);
17919 if (PyErr_Occurred()) SWIG_fail;
17920 }
17921 resultobj = SWIG_Py_Void();
17922 return resultobj;
17923 fail:
17924 return NULL;
17925 }
17926
17927
17928 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17929 PyObject *resultobj = 0;
17930 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17931 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17932 void *argp1 = 0 ;
17933 int res1 = 0 ;
17934 void *argp2 = 0 ;
17935 int res2 = 0 ;
17936 PyObject * obj0 = 0 ;
17937 PyObject * obj1 = 0 ;
17938 char * kwnames[] = {
17939 (char *) "self",(char *) "handler", NULL
17940 };
17941
17942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17946 }
17947 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17949 if (!SWIG_IsOK(res2)) {
17950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17951 }
17952 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 (arg1)->SetPreviousHandler(arg2);
17956 wxPyEndAllowThreads(__tstate);
17957 if (PyErr_Occurred()) SWIG_fail;
17958 }
17959 resultobj = SWIG_Py_Void();
17960 return resultobj;
17961 fail:
17962 return NULL;
17963 }
17964
17965
17966 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17967 PyObject *resultobj = 0;
17968 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17969 bool result;
17970 void *argp1 = 0 ;
17971 int res1 = 0 ;
17972 PyObject *swig_obj[1] ;
17973
17974 if (!args) SWIG_fail;
17975 swig_obj[0] = args;
17976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17979 }
17980 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (bool)(arg1)->GetEvtHandlerEnabled();
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 {
17988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17989 }
17990 return resultobj;
17991 fail:
17992 return NULL;
17993 }
17994
17995
17996 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj = 0;
17998 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17999 bool arg2 ;
18000 void *argp1 = 0 ;
18001 int res1 = 0 ;
18002 bool val2 ;
18003 int ecode2 = 0 ;
18004 PyObject * obj0 = 0 ;
18005 PyObject * obj1 = 0 ;
18006 char * kwnames[] = {
18007 (char *) "self",(char *) "enabled", NULL
18008 };
18009
18010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18012 if (!SWIG_IsOK(res1)) {
18013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18014 }
18015 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18016 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18017 if (!SWIG_IsOK(ecode2)) {
18018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18019 }
18020 arg2 = static_cast< bool >(val2);
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 (arg1)->SetEvtHandlerEnabled(arg2);
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 resultobj = SWIG_Py_Void();
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj = 0;
18036 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18037 wxEvent *arg2 = 0 ;
18038 bool result;
18039 void *argp1 = 0 ;
18040 int res1 = 0 ;
18041 void *argp2 = 0 ;
18042 int res2 = 0 ;
18043 PyObject * obj0 = 0 ;
18044 PyObject * obj1 = 0 ;
18045 char * kwnames[] = {
18046 (char *) "self",(char *) "event", NULL
18047 };
18048
18049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18051 if (!SWIG_IsOK(res1)) {
18052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18053 }
18054 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18056 if (!SWIG_IsOK(res2)) {
18057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18058 }
18059 if (!argp2) {
18060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18061 }
18062 arg2 = reinterpret_cast< wxEvent * >(argp2);
18063 {
18064 PyThreadState* __tstate = wxPyBeginAllowThreads();
18065 result = (bool)(arg1)->ProcessEvent(*arg2);
18066 wxPyEndAllowThreads(__tstate);
18067 if (PyErr_Occurred()) SWIG_fail;
18068 }
18069 {
18070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18071 }
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj = 0;
18080 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18081 wxEvent *arg2 = 0 ;
18082 void *argp1 = 0 ;
18083 int res1 = 0 ;
18084 void *argp2 = 0 ;
18085 int res2 = 0 ;
18086 PyObject * obj0 = 0 ;
18087 PyObject * obj1 = 0 ;
18088 char * kwnames[] = {
18089 (char *) "self",(char *) "event", NULL
18090 };
18091
18092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18094 if (!SWIG_IsOK(res1)) {
18095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18096 }
18097 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18099 if (!SWIG_IsOK(res2)) {
18100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18101 }
18102 if (!argp2) {
18103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18104 }
18105 arg2 = reinterpret_cast< wxEvent * >(argp2);
18106 {
18107 PyThreadState* __tstate = wxPyBeginAllowThreads();
18108 (arg1)->AddPendingEvent(*arg2);
18109 wxPyEndAllowThreads(__tstate);
18110 if (PyErr_Occurred()) SWIG_fail;
18111 }
18112 resultobj = SWIG_Py_Void();
18113 return resultobj;
18114 fail:
18115 return NULL;
18116 }
18117
18118
18119 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18120 PyObject *resultobj = 0;
18121 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18122 void *argp1 = 0 ;
18123 int res1 = 0 ;
18124 PyObject *swig_obj[1] ;
18125
18126 if (!args) SWIG_fail;
18127 swig_obj[0] = args;
18128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18129 if (!SWIG_IsOK(res1)) {
18130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18131 }
18132 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 (arg1)->ProcessPendingEvents();
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = SWIG_Py_Void();
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18147 PyObject *resultobj = 0;
18148 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18149 int arg2 ;
18150 int arg3 ;
18151 int arg4 ;
18152 PyObject *arg5 = (PyObject *) 0 ;
18153 void *argp1 = 0 ;
18154 int res1 = 0 ;
18155 int val2 ;
18156 int ecode2 = 0 ;
18157 int val3 ;
18158 int ecode3 = 0 ;
18159 int val4 ;
18160 int ecode4 = 0 ;
18161 PyObject * obj0 = 0 ;
18162 PyObject * obj1 = 0 ;
18163 PyObject * obj2 = 0 ;
18164 PyObject * obj3 = 0 ;
18165 PyObject * obj4 = 0 ;
18166 char * kwnames[] = {
18167 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18168 };
18169
18170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18172 if (!SWIG_IsOK(res1)) {
18173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18174 }
18175 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18176 ecode2 = SWIG_AsVal_int(obj1, &val2);
18177 if (!SWIG_IsOK(ecode2)) {
18178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18179 }
18180 arg2 = static_cast< int >(val2);
18181 ecode3 = SWIG_AsVal_int(obj2, &val3);
18182 if (!SWIG_IsOK(ecode3)) {
18183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18184 }
18185 arg3 = static_cast< int >(val3);
18186 ecode4 = SWIG_AsVal_int(obj3, &val4);
18187 if (!SWIG_IsOK(ecode4)) {
18188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18189 }
18190 arg4 = static_cast< int >(val4);
18191 arg5 = obj4;
18192 {
18193 PyThreadState* __tstate = wxPyBeginAllowThreads();
18194 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18195 wxPyEndAllowThreads(__tstate);
18196 if (PyErr_Occurred()) SWIG_fail;
18197 }
18198 resultobj = SWIG_Py_Void();
18199 return resultobj;
18200 fail:
18201 return NULL;
18202 }
18203
18204
18205 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18206 PyObject *resultobj = 0;
18207 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18208 int arg2 ;
18209 int arg3 = (int) -1 ;
18210 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18211 bool result;
18212 void *argp1 = 0 ;
18213 int res1 = 0 ;
18214 int val2 ;
18215 int ecode2 = 0 ;
18216 int val3 ;
18217 int ecode3 = 0 ;
18218 int val4 ;
18219 int ecode4 = 0 ;
18220 PyObject * obj0 = 0 ;
18221 PyObject * obj1 = 0 ;
18222 PyObject * obj2 = 0 ;
18223 PyObject * obj3 = 0 ;
18224 char * kwnames[] = {
18225 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18226 };
18227
18228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18230 if (!SWIG_IsOK(res1)) {
18231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18232 }
18233 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18234 ecode2 = SWIG_AsVal_int(obj1, &val2);
18235 if (!SWIG_IsOK(ecode2)) {
18236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18237 }
18238 arg2 = static_cast< int >(val2);
18239 if (obj2) {
18240 ecode3 = SWIG_AsVal_int(obj2, &val3);
18241 if (!SWIG_IsOK(ecode3)) {
18242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18243 }
18244 arg3 = static_cast< int >(val3);
18245 }
18246 if (obj3) {
18247 ecode4 = SWIG_AsVal_int(obj3, &val4);
18248 if (!SWIG_IsOK(ecode4)) {
18249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18250 }
18251 arg4 = static_cast< wxEventType >(val4);
18252 }
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 {
18260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18261 }
18262 return resultobj;
18263 fail:
18264 return NULL;
18265 }
18266
18267
18268 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18269 PyObject *resultobj = 0;
18270 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18271 PyObject *arg2 = (PyObject *) 0 ;
18272 bool arg3 = (bool) true ;
18273 void *argp1 = 0 ;
18274 int res1 = 0 ;
18275 bool val3 ;
18276 int ecode3 = 0 ;
18277 PyObject * obj0 = 0 ;
18278 PyObject * obj1 = 0 ;
18279 PyObject * obj2 = 0 ;
18280 char * kwnames[] = {
18281 (char *) "self",(char *) "_self",(char *) "incref", NULL
18282 };
18283
18284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18286 if (!SWIG_IsOK(res1)) {
18287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18288 }
18289 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18290 arg2 = obj1;
18291 if (obj2) {
18292 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18293 if (!SWIG_IsOK(ecode3)) {
18294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18295 }
18296 arg3 = static_cast< bool >(val3);
18297 }
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 resultobj = SWIG_Py_Void();
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18312 PyObject *obj;
18313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18314 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18315 return SWIG_Py_Void();
18316 }
18317
18318 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18319 return SWIG_Python_InitShadowInstance(args);
18320 }
18321
18322 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18323 PyObject *resultobj = 0;
18324 wxEventType result;
18325
18326 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18327 {
18328 PyThreadState* __tstate = wxPyBeginAllowThreads();
18329 result = (wxEventType)wxNewEventType();
18330 wxPyEndAllowThreads(__tstate);
18331 if (PyErr_Occurred()) SWIG_fail;
18332 }
18333 resultobj = SWIG_From_int(static_cast< int >(result));
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18341 PyObject *resultobj = 0;
18342 wxEvent *arg1 = (wxEvent *) 0 ;
18343 void *argp1 = 0 ;
18344 int res1 = 0 ;
18345 PyObject *swig_obj[1] ;
18346
18347 if (!args) SWIG_fail;
18348 swig_obj[0] = args;
18349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18350 if (!SWIG_IsOK(res1)) {
18351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18352 }
18353 arg1 = reinterpret_cast< wxEvent * >(argp1);
18354 {
18355 PyThreadState* __tstate = wxPyBeginAllowThreads();
18356 delete arg1;
18357
18358 wxPyEndAllowThreads(__tstate);
18359 if (PyErr_Occurred()) SWIG_fail;
18360 }
18361 resultobj = SWIG_Py_Void();
18362 return resultobj;
18363 fail:
18364 return NULL;
18365 }
18366
18367
18368 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18369 PyObject *resultobj = 0;
18370 wxEvent *arg1 = (wxEvent *) 0 ;
18371 wxEventType arg2 ;
18372 void *argp1 = 0 ;
18373 int res1 = 0 ;
18374 int val2 ;
18375 int ecode2 = 0 ;
18376 PyObject * obj0 = 0 ;
18377 PyObject * obj1 = 0 ;
18378 char * kwnames[] = {
18379 (char *) "self",(char *) "typ", NULL
18380 };
18381
18382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18384 if (!SWIG_IsOK(res1)) {
18385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18386 }
18387 arg1 = reinterpret_cast< wxEvent * >(argp1);
18388 ecode2 = SWIG_AsVal_int(obj1, &val2);
18389 if (!SWIG_IsOK(ecode2)) {
18390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18391 }
18392 arg2 = static_cast< wxEventType >(val2);
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 (arg1)->SetEventType(arg2);
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 resultobj = SWIG_Py_Void();
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18407 PyObject *resultobj = 0;
18408 wxEvent *arg1 = (wxEvent *) 0 ;
18409 wxEventType result;
18410 void *argp1 = 0 ;
18411 int res1 = 0 ;
18412 PyObject *swig_obj[1] ;
18413
18414 if (!args) SWIG_fail;
18415 swig_obj[0] = args;
18416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18417 if (!SWIG_IsOK(res1)) {
18418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18419 }
18420 arg1 = reinterpret_cast< wxEvent * >(argp1);
18421 {
18422 PyThreadState* __tstate = wxPyBeginAllowThreads();
18423 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18424 wxPyEndAllowThreads(__tstate);
18425 if (PyErr_Occurred()) SWIG_fail;
18426 }
18427 resultobj = SWIG_From_int(static_cast< int >(result));
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18435 PyObject *resultobj = 0;
18436 wxEvent *arg1 = (wxEvent *) 0 ;
18437 wxObject *result = 0 ;
18438 void *argp1 = 0 ;
18439 int res1 = 0 ;
18440 PyObject *swig_obj[1] ;
18441
18442 if (!args) SWIG_fail;
18443 swig_obj[0] = args;
18444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18445 if (!SWIG_IsOK(res1)) {
18446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18447 }
18448 arg1 = reinterpret_cast< wxEvent * >(argp1);
18449 {
18450 PyThreadState* __tstate = wxPyBeginAllowThreads();
18451 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18452 wxPyEndAllowThreads(__tstate);
18453 if (PyErr_Occurred()) SWIG_fail;
18454 }
18455 {
18456 resultobj = wxPyMake_wxObject(result, (bool)0);
18457 }
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18465 PyObject *resultobj = 0;
18466 wxEvent *arg1 = (wxEvent *) 0 ;
18467 wxObject *arg2 = (wxObject *) 0 ;
18468 void *argp1 = 0 ;
18469 int res1 = 0 ;
18470 void *argp2 = 0 ;
18471 int res2 = 0 ;
18472 PyObject * obj0 = 0 ;
18473 PyObject * obj1 = 0 ;
18474 char * kwnames[] = {
18475 (char *) "self",(char *) "obj", NULL
18476 };
18477
18478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18482 }
18483 arg1 = reinterpret_cast< wxEvent * >(argp1);
18484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18485 if (!SWIG_IsOK(res2)) {
18486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18487 }
18488 arg2 = reinterpret_cast< wxObject * >(argp2);
18489 {
18490 PyThreadState* __tstate = wxPyBeginAllowThreads();
18491 (arg1)->SetEventObject(arg2);
18492 wxPyEndAllowThreads(__tstate);
18493 if (PyErr_Occurred()) SWIG_fail;
18494 }
18495 resultobj = SWIG_Py_Void();
18496 return resultobj;
18497 fail:
18498 return NULL;
18499 }
18500
18501
18502 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18503 PyObject *resultobj = 0;
18504 wxEvent *arg1 = (wxEvent *) 0 ;
18505 long result;
18506 void *argp1 = 0 ;
18507 int res1 = 0 ;
18508 PyObject *swig_obj[1] ;
18509
18510 if (!args) SWIG_fail;
18511 swig_obj[0] = args;
18512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18513 if (!SWIG_IsOK(res1)) {
18514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18515 }
18516 arg1 = reinterpret_cast< wxEvent * >(argp1);
18517 {
18518 PyThreadState* __tstate = wxPyBeginAllowThreads();
18519 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18520 wxPyEndAllowThreads(__tstate);
18521 if (PyErr_Occurred()) SWIG_fail;
18522 }
18523 resultobj = SWIG_From_long(static_cast< long >(result));
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj = 0;
18532 wxEvent *arg1 = (wxEvent *) 0 ;
18533 long arg2 = (long) 0 ;
18534 void *argp1 = 0 ;
18535 int res1 = 0 ;
18536 long val2 ;
18537 int ecode2 = 0 ;
18538 PyObject * obj0 = 0 ;
18539 PyObject * obj1 = 0 ;
18540 char * kwnames[] = {
18541 (char *) "self",(char *) "ts", NULL
18542 };
18543
18544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18546 if (!SWIG_IsOK(res1)) {
18547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18548 }
18549 arg1 = reinterpret_cast< wxEvent * >(argp1);
18550 if (obj1) {
18551 ecode2 = SWIG_AsVal_long(obj1, &val2);
18552 if (!SWIG_IsOK(ecode2)) {
18553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18554 }
18555 arg2 = static_cast< long >(val2);
18556 }
18557 {
18558 PyThreadState* __tstate = wxPyBeginAllowThreads();
18559 (arg1)->SetTimestamp(arg2);
18560 wxPyEndAllowThreads(__tstate);
18561 if (PyErr_Occurred()) SWIG_fail;
18562 }
18563 resultobj = SWIG_Py_Void();
18564 return resultobj;
18565 fail:
18566 return NULL;
18567 }
18568
18569
18570 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18571 PyObject *resultobj = 0;
18572 wxEvent *arg1 = (wxEvent *) 0 ;
18573 int result;
18574 void *argp1 = 0 ;
18575 int res1 = 0 ;
18576 PyObject *swig_obj[1] ;
18577
18578 if (!args) SWIG_fail;
18579 swig_obj[0] = args;
18580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18581 if (!SWIG_IsOK(res1)) {
18582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18583 }
18584 arg1 = reinterpret_cast< wxEvent * >(argp1);
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (int)((wxEvent const *)arg1)->GetId();
18588 wxPyEndAllowThreads(__tstate);
18589 if (PyErr_Occurred()) SWIG_fail;
18590 }
18591 resultobj = SWIG_From_int(static_cast< int >(result));
18592 return resultobj;
18593 fail:
18594 return NULL;
18595 }
18596
18597
18598 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18599 PyObject *resultobj = 0;
18600 wxEvent *arg1 = (wxEvent *) 0 ;
18601 int arg2 ;
18602 void *argp1 = 0 ;
18603 int res1 = 0 ;
18604 int val2 ;
18605 int ecode2 = 0 ;
18606 PyObject * obj0 = 0 ;
18607 PyObject * obj1 = 0 ;
18608 char * kwnames[] = {
18609 (char *) "self",(char *) "Id", NULL
18610 };
18611
18612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18614 if (!SWIG_IsOK(res1)) {
18615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18616 }
18617 arg1 = reinterpret_cast< wxEvent * >(argp1);
18618 ecode2 = SWIG_AsVal_int(obj1, &val2);
18619 if (!SWIG_IsOK(ecode2)) {
18620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18621 }
18622 arg2 = static_cast< int >(val2);
18623 {
18624 PyThreadState* __tstate = wxPyBeginAllowThreads();
18625 (arg1)->SetId(arg2);
18626 wxPyEndAllowThreads(__tstate);
18627 if (PyErr_Occurred()) SWIG_fail;
18628 }
18629 resultobj = SWIG_Py_Void();
18630 return resultobj;
18631 fail:
18632 return NULL;
18633 }
18634
18635
18636 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18637 PyObject *resultobj = 0;
18638 wxEvent *arg1 = (wxEvent *) 0 ;
18639 bool result;
18640 void *argp1 = 0 ;
18641 int res1 = 0 ;
18642 PyObject *swig_obj[1] ;
18643
18644 if (!args) SWIG_fail;
18645 swig_obj[0] = args;
18646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18647 if (!SWIG_IsOK(res1)) {
18648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18649 }
18650 arg1 = reinterpret_cast< wxEvent * >(argp1);
18651 {
18652 PyThreadState* __tstate = wxPyBeginAllowThreads();
18653 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 {
18658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18659 }
18660 return resultobj;
18661 fail:
18662 return NULL;
18663 }
18664
18665
18666 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18667 PyObject *resultobj = 0;
18668 wxEvent *arg1 = (wxEvent *) 0 ;
18669 bool arg2 = (bool) true ;
18670 void *argp1 = 0 ;
18671 int res1 = 0 ;
18672 bool val2 ;
18673 int ecode2 = 0 ;
18674 PyObject * obj0 = 0 ;
18675 PyObject * obj1 = 0 ;
18676 char * kwnames[] = {
18677 (char *) "self",(char *) "skip", NULL
18678 };
18679
18680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18682 if (!SWIG_IsOK(res1)) {
18683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18684 }
18685 arg1 = reinterpret_cast< wxEvent * >(argp1);
18686 if (obj1) {
18687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18688 if (!SWIG_IsOK(ecode2)) {
18689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18690 }
18691 arg2 = static_cast< bool >(val2);
18692 }
18693 {
18694 PyThreadState* __tstate = wxPyBeginAllowThreads();
18695 (arg1)->Skip(arg2);
18696 wxPyEndAllowThreads(__tstate);
18697 if (PyErr_Occurred()) SWIG_fail;
18698 }
18699 resultobj = SWIG_Py_Void();
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18707 PyObject *resultobj = 0;
18708 wxEvent *arg1 = (wxEvent *) 0 ;
18709 bool result;
18710 void *argp1 = 0 ;
18711 int res1 = 0 ;
18712 PyObject *swig_obj[1] ;
18713
18714 if (!args) SWIG_fail;
18715 swig_obj[0] = args;
18716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18717 if (!SWIG_IsOK(res1)) {
18718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18719 }
18720 arg1 = reinterpret_cast< wxEvent * >(argp1);
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 {
18728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18729 }
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737 PyObject *resultobj = 0;
18738 wxEvent *arg1 = (wxEvent *) 0 ;
18739 bool result;
18740 void *argp1 = 0 ;
18741 int res1 = 0 ;
18742 PyObject *swig_obj[1] ;
18743
18744 if (!args) SWIG_fail;
18745 swig_obj[0] = args;
18746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18747 if (!SWIG_IsOK(res1)) {
18748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18749 }
18750 arg1 = reinterpret_cast< wxEvent * >(argp1);
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18754 wxPyEndAllowThreads(__tstate);
18755 if (PyErr_Occurred()) SWIG_fail;
18756 }
18757 {
18758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18759 }
18760 return resultobj;
18761 fail:
18762 return NULL;
18763 }
18764
18765
18766 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18767 PyObject *resultobj = 0;
18768 wxEvent *arg1 = (wxEvent *) 0 ;
18769 int result;
18770 void *argp1 = 0 ;
18771 int res1 = 0 ;
18772 PyObject *swig_obj[1] ;
18773
18774 if (!args) SWIG_fail;
18775 swig_obj[0] = args;
18776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18779 }
18780 arg1 = reinterpret_cast< wxEvent * >(argp1);
18781 {
18782 PyThreadState* __tstate = wxPyBeginAllowThreads();
18783 result = (int)(arg1)->StopPropagation();
18784 wxPyEndAllowThreads(__tstate);
18785 if (PyErr_Occurred()) SWIG_fail;
18786 }
18787 resultobj = SWIG_From_int(static_cast< int >(result));
18788 return resultobj;
18789 fail:
18790 return NULL;
18791 }
18792
18793
18794 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18795 PyObject *resultobj = 0;
18796 wxEvent *arg1 = (wxEvent *) 0 ;
18797 int arg2 ;
18798 void *argp1 = 0 ;
18799 int res1 = 0 ;
18800 int val2 ;
18801 int ecode2 = 0 ;
18802 PyObject * obj0 = 0 ;
18803 PyObject * obj1 = 0 ;
18804 char * kwnames[] = {
18805 (char *) "self",(char *) "propagationLevel", NULL
18806 };
18807
18808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18810 if (!SWIG_IsOK(res1)) {
18811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18812 }
18813 arg1 = reinterpret_cast< wxEvent * >(argp1);
18814 ecode2 = SWIG_AsVal_int(obj1, &val2);
18815 if (!SWIG_IsOK(ecode2)) {
18816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18817 }
18818 arg2 = static_cast< int >(val2);
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 (arg1)->ResumePropagation(arg2);
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 resultobj = SWIG_Py_Void();
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 PyObject *resultobj = 0;
18834 wxEvent *arg1 = (wxEvent *) 0 ;
18835 wxEvent *result = 0 ;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 PyObject *swig_obj[1] ;
18839
18840 if (!args) SWIG_fail;
18841 swig_obj[0] = args;
18842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18845 }
18846 arg1 = reinterpret_cast< wxEvent * >(argp1);
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = (wxEvent *)(arg1)->Clone();
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18861 PyObject *obj;
18862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18863 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18864 return SWIG_Py_Void();
18865 }
18866
18867 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18868 PyObject *resultobj = 0;
18869 wxEvent *arg1 = 0 ;
18870 wxPropagationDisabler *result = 0 ;
18871 void *argp1 = 0 ;
18872 int res1 = 0 ;
18873 PyObject * obj0 = 0 ;
18874 char * kwnames[] = {
18875 (char *) "event", NULL
18876 };
18877
18878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18879 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18880 if (!SWIG_IsOK(res1)) {
18881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18882 }
18883 if (!argp1) {
18884 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18885 }
18886 arg1 = reinterpret_cast< wxEvent * >(argp1);
18887 {
18888 PyThreadState* __tstate = wxPyBeginAllowThreads();
18889 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18890 wxPyEndAllowThreads(__tstate);
18891 if (PyErr_Occurred()) SWIG_fail;
18892 }
18893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18901 PyObject *resultobj = 0;
18902 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18903 void *argp1 = 0 ;
18904 int res1 = 0 ;
18905 PyObject *swig_obj[1] ;
18906
18907 if (!args) SWIG_fail;
18908 swig_obj[0] = args;
18909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18910 if (!SWIG_IsOK(res1)) {
18911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18912 }
18913 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 delete arg1;
18917
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = SWIG_Py_Void();
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18929 PyObject *obj;
18930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18931 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18932 return SWIG_Py_Void();
18933 }
18934
18935 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18936 return SWIG_Python_InitShadowInstance(args);
18937 }
18938
18939 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18940 PyObject *resultobj = 0;
18941 wxEvent *arg1 = 0 ;
18942 wxPropagateOnce *result = 0 ;
18943 void *argp1 = 0 ;
18944 int res1 = 0 ;
18945 PyObject * obj0 = 0 ;
18946 char * kwnames[] = {
18947 (char *) "event", NULL
18948 };
18949
18950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18951 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18952 if (!SWIG_IsOK(res1)) {
18953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18954 }
18955 if (!argp1) {
18956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18957 }
18958 arg1 = reinterpret_cast< wxEvent * >(argp1);
18959 {
18960 PyThreadState* __tstate = wxPyBeginAllowThreads();
18961 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18962 wxPyEndAllowThreads(__tstate);
18963 if (PyErr_Occurred()) SWIG_fail;
18964 }
18965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18966 return resultobj;
18967 fail:
18968 return NULL;
18969 }
18970
18971
18972 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18973 PyObject *resultobj = 0;
18974 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18975 void *argp1 = 0 ;
18976 int res1 = 0 ;
18977 PyObject *swig_obj[1] ;
18978
18979 if (!args) SWIG_fail;
18980 swig_obj[0] = args;
18981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18982 if (!SWIG_IsOK(res1)) {
18983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18984 }
18985 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18986 {
18987 PyThreadState* __tstate = wxPyBeginAllowThreads();
18988 delete arg1;
18989
18990 wxPyEndAllowThreads(__tstate);
18991 if (PyErr_Occurred()) SWIG_fail;
18992 }
18993 resultobj = SWIG_Py_Void();
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19001 PyObject *obj;
19002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19003 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19004 return SWIG_Py_Void();
19005 }
19006
19007 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19008 return SWIG_Python_InitShadowInstance(args);
19009 }
19010
19011 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19012 PyObject *resultobj = 0;
19013 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19014 int arg2 = (int) 0 ;
19015 wxCommandEvent *result = 0 ;
19016 int val1 ;
19017 int ecode1 = 0 ;
19018 int val2 ;
19019 int ecode2 = 0 ;
19020 PyObject * obj0 = 0 ;
19021 PyObject * obj1 = 0 ;
19022 char * kwnames[] = {
19023 (char *) "commandType",(char *) "winid", NULL
19024 };
19025
19026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19027 if (obj0) {
19028 ecode1 = SWIG_AsVal_int(obj0, &val1);
19029 if (!SWIG_IsOK(ecode1)) {
19030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19031 }
19032 arg1 = static_cast< wxEventType >(val1);
19033 }
19034 if (obj1) {
19035 ecode2 = SWIG_AsVal_int(obj1, &val2);
19036 if (!SWIG_IsOK(ecode2)) {
19037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19038 }
19039 arg2 = static_cast< int >(val2);
19040 }
19041 {
19042 PyThreadState* __tstate = wxPyBeginAllowThreads();
19043 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19044 wxPyEndAllowThreads(__tstate);
19045 if (PyErr_Occurred()) SWIG_fail;
19046 }
19047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19048 return resultobj;
19049 fail:
19050 return NULL;
19051 }
19052
19053
19054 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19055 PyObject *resultobj = 0;
19056 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19057 int result;
19058 void *argp1 = 0 ;
19059 int res1 = 0 ;
19060 PyObject *swig_obj[1] ;
19061
19062 if (!args) SWIG_fail;
19063 swig_obj[0] = args;
19064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19065 if (!SWIG_IsOK(res1)) {
19066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19067 }
19068 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19069 {
19070 PyThreadState* __tstate = wxPyBeginAllowThreads();
19071 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19072 wxPyEndAllowThreads(__tstate);
19073 if (PyErr_Occurred()) SWIG_fail;
19074 }
19075 resultobj = SWIG_From_int(static_cast< int >(result));
19076 return resultobj;
19077 fail:
19078 return NULL;
19079 }
19080
19081
19082 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19083 PyObject *resultobj = 0;
19084 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19085 wxString *arg2 = 0 ;
19086 void *argp1 = 0 ;
19087 int res1 = 0 ;
19088 bool temp2 = false ;
19089 PyObject * obj0 = 0 ;
19090 PyObject * obj1 = 0 ;
19091 char * kwnames[] = {
19092 (char *) "self",(char *) "s", NULL
19093 };
19094
19095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19097 if (!SWIG_IsOK(res1)) {
19098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19099 }
19100 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19101 {
19102 arg2 = wxString_in_helper(obj1);
19103 if (arg2 == NULL) SWIG_fail;
19104 temp2 = true;
19105 }
19106 {
19107 PyThreadState* __tstate = wxPyBeginAllowThreads();
19108 (arg1)->SetString((wxString const &)*arg2);
19109 wxPyEndAllowThreads(__tstate);
19110 if (PyErr_Occurred()) SWIG_fail;
19111 }
19112 resultobj = SWIG_Py_Void();
19113 {
19114 if (temp2)
19115 delete arg2;
19116 }
19117 return resultobj;
19118 fail:
19119 {
19120 if (temp2)
19121 delete arg2;
19122 }
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19128 PyObject *resultobj = 0;
19129 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19130 wxString result;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 PyObject *swig_obj[1] ;
19134
19135 if (!args) SWIG_fail;
19136 swig_obj[0] = args;
19137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19138 if (!SWIG_IsOK(res1)) {
19139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19140 }
19141 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = ((wxCommandEvent const *)arg1)->GetString();
19145 wxPyEndAllowThreads(__tstate);
19146 if (PyErr_Occurred()) SWIG_fail;
19147 }
19148 {
19149 #if wxUSE_UNICODE
19150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19151 #else
19152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19153 #endif
19154 }
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19162 PyObject *resultobj = 0;
19163 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19164 bool result;
19165 void *argp1 = 0 ;
19166 int res1 = 0 ;
19167 PyObject *swig_obj[1] ;
19168
19169 if (!args) SWIG_fail;
19170 swig_obj[0] = args;
19171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19172 if (!SWIG_IsOK(res1)) {
19173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19174 }
19175 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19176 {
19177 PyThreadState* __tstate = wxPyBeginAllowThreads();
19178 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19179 wxPyEndAllowThreads(__tstate);
19180 if (PyErr_Occurred()) SWIG_fail;
19181 }
19182 {
19183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19184 }
19185 return resultobj;
19186 fail:
19187 return NULL;
19188 }
19189
19190
19191 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19192 PyObject *resultobj = 0;
19193 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19194 bool result;
19195 void *argp1 = 0 ;
19196 int res1 = 0 ;
19197 PyObject *swig_obj[1] ;
19198
19199 if (!args) SWIG_fail;
19200 swig_obj[0] = args;
19201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19202 if (!SWIG_IsOK(res1)) {
19203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19204 }
19205 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19206 {
19207 PyThreadState* __tstate = wxPyBeginAllowThreads();
19208 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19209 wxPyEndAllowThreads(__tstate);
19210 if (PyErr_Occurred()) SWIG_fail;
19211 }
19212 {
19213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19214 }
19215 return resultobj;
19216 fail:
19217 return NULL;
19218 }
19219
19220
19221 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj = 0;
19223 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19224 long arg2 ;
19225 void *argp1 = 0 ;
19226 int res1 = 0 ;
19227 long val2 ;
19228 int ecode2 = 0 ;
19229 PyObject * obj0 = 0 ;
19230 PyObject * obj1 = 0 ;
19231 char * kwnames[] = {
19232 (char *) "self",(char *) "extraLong", NULL
19233 };
19234
19235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19237 if (!SWIG_IsOK(res1)) {
19238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19239 }
19240 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19241 ecode2 = SWIG_AsVal_long(obj1, &val2);
19242 if (!SWIG_IsOK(ecode2)) {
19243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19244 }
19245 arg2 = static_cast< long >(val2);
19246 {
19247 PyThreadState* __tstate = wxPyBeginAllowThreads();
19248 (arg1)->SetExtraLong(arg2);
19249 wxPyEndAllowThreads(__tstate);
19250 if (PyErr_Occurred()) SWIG_fail;
19251 }
19252 resultobj = SWIG_Py_Void();
19253 return resultobj;
19254 fail:
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19260 PyObject *resultobj = 0;
19261 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19262 long result;
19263 void *argp1 = 0 ;
19264 int res1 = 0 ;
19265 PyObject *swig_obj[1] ;
19266
19267 if (!args) SWIG_fail;
19268 swig_obj[0] = args;
19269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19270 if (!SWIG_IsOK(res1)) {
19271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19272 }
19273 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19274 {
19275 PyThreadState* __tstate = wxPyBeginAllowThreads();
19276 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19277 wxPyEndAllowThreads(__tstate);
19278 if (PyErr_Occurred()) SWIG_fail;
19279 }
19280 resultobj = SWIG_From_long(static_cast< long >(result));
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19288 PyObject *resultobj = 0;
19289 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19290 int arg2 ;
19291 void *argp1 = 0 ;
19292 int res1 = 0 ;
19293 int val2 ;
19294 int ecode2 = 0 ;
19295 PyObject * obj0 = 0 ;
19296 PyObject * obj1 = 0 ;
19297 char * kwnames[] = {
19298 (char *) "self",(char *) "i", NULL
19299 };
19300
19301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19303 if (!SWIG_IsOK(res1)) {
19304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19305 }
19306 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19307 ecode2 = SWIG_AsVal_int(obj1, &val2);
19308 if (!SWIG_IsOK(ecode2)) {
19309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19310 }
19311 arg2 = static_cast< int >(val2);
19312 {
19313 PyThreadState* __tstate = wxPyBeginAllowThreads();
19314 (arg1)->SetInt(arg2);
19315 wxPyEndAllowThreads(__tstate);
19316 if (PyErr_Occurred()) SWIG_fail;
19317 }
19318 resultobj = SWIG_Py_Void();
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19326 PyObject *resultobj = 0;
19327 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19328 int result;
19329 void *argp1 = 0 ;
19330 int res1 = 0 ;
19331 PyObject *swig_obj[1] ;
19332
19333 if (!args) SWIG_fail;
19334 swig_obj[0] = args;
19335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19336 if (!SWIG_IsOK(res1)) {
19337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19338 }
19339 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19340 {
19341 PyThreadState* __tstate = wxPyBeginAllowThreads();
19342 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 resultobj = SWIG_From_int(static_cast< int >(result));
19347 return resultobj;
19348 fail:
19349 return NULL;
19350 }
19351
19352
19353 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19354 PyObject *resultobj = 0;
19355 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19356 PyObject *result = 0 ;
19357 void *argp1 = 0 ;
19358 int res1 = 0 ;
19359 PyObject *swig_obj[1] ;
19360
19361 if (!args) SWIG_fail;
19362 swig_obj[0] = args;
19363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19364 if (!SWIG_IsOK(res1)) {
19365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19366 }
19367 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19368 {
19369 PyThreadState* __tstate = wxPyBeginAllowThreads();
19370 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19371 wxPyEndAllowThreads(__tstate);
19372 if (PyErr_Occurred()) SWIG_fail;
19373 }
19374 resultobj = result;
19375 return resultobj;
19376 fail:
19377 return NULL;
19378 }
19379
19380
19381 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19382 PyObject *resultobj = 0;
19383 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19384 PyObject *arg2 = (PyObject *) 0 ;
19385 void *argp1 = 0 ;
19386 int res1 = 0 ;
19387 PyObject * obj0 = 0 ;
19388 PyObject * obj1 = 0 ;
19389 char * kwnames[] = {
19390 (char *) "self",(char *) "clientData", NULL
19391 };
19392
19393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19395 if (!SWIG_IsOK(res1)) {
19396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19397 }
19398 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19399 arg2 = obj1;
19400 {
19401 PyThreadState* __tstate = wxPyBeginAllowThreads();
19402 wxCommandEvent_SetClientData(arg1,arg2);
19403 wxPyEndAllowThreads(__tstate);
19404 if (PyErr_Occurred()) SWIG_fail;
19405 }
19406 resultobj = SWIG_Py_Void();
19407 return resultobj;
19408 fail:
19409 return NULL;
19410 }
19411
19412
19413 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19414 PyObject *resultobj = 0;
19415 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19416 wxEvent *result = 0 ;
19417 void *argp1 = 0 ;
19418 int res1 = 0 ;
19419 PyObject *swig_obj[1] ;
19420
19421 if (!args) SWIG_fail;
19422 swig_obj[0] = args;
19423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19424 if (!SWIG_IsOK(res1)) {
19425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19426 }
19427 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19428 {
19429 PyThreadState* __tstate = wxPyBeginAllowThreads();
19430 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19431 wxPyEndAllowThreads(__tstate);
19432 if (PyErr_Occurred()) SWIG_fail;
19433 }
19434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19435 return resultobj;
19436 fail:
19437 return NULL;
19438 }
19439
19440
19441 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19442 PyObject *obj;
19443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19444 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19445 return SWIG_Py_Void();
19446 }
19447
19448 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 return SWIG_Python_InitShadowInstance(args);
19450 }
19451
19452 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj = 0;
19454 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19455 int arg2 = (int) 0 ;
19456 wxNotifyEvent *result = 0 ;
19457 int val1 ;
19458 int ecode1 = 0 ;
19459 int val2 ;
19460 int ecode2 = 0 ;
19461 PyObject * obj0 = 0 ;
19462 PyObject * obj1 = 0 ;
19463 char * kwnames[] = {
19464 (char *) "commandType",(char *) "winid", NULL
19465 };
19466
19467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19468 if (obj0) {
19469 ecode1 = SWIG_AsVal_int(obj0, &val1);
19470 if (!SWIG_IsOK(ecode1)) {
19471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19472 }
19473 arg1 = static_cast< wxEventType >(val1);
19474 }
19475 if (obj1) {
19476 ecode2 = SWIG_AsVal_int(obj1, &val2);
19477 if (!SWIG_IsOK(ecode2)) {
19478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19479 }
19480 arg2 = static_cast< int >(val2);
19481 }
19482 {
19483 PyThreadState* __tstate = wxPyBeginAllowThreads();
19484 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19485 wxPyEndAllowThreads(__tstate);
19486 if (PyErr_Occurred()) SWIG_fail;
19487 }
19488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19489 return resultobj;
19490 fail:
19491 return NULL;
19492 }
19493
19494
19495 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19496 PyObject *resultobj = 0;
19497 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19498 void *argp1 = 0 ;
19499 int res1 = 0 ;
19500 PyObject *swig_obj[1] ;
19501
19502 if (!args) SWIG_fail;
19503 swig_obj[0] = args;
19504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19505 if (!SWIG_IsOK(res1)) {
19506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19507 }
19508 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19509 {
19510 PyThreadState* __tstate = wxPyBeginAllowThreads();
19511 (arg1)->Veto();
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 resultobj = SWIG_Py_Void();
19516 return resultobj;
19517 fail:
19518 return NULL;
19519 }
19520
19521
19522 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19523 PyObject *resultobj = 0;
19524 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19525 void *argp1 = 0 ;
19526 int res1 = 0 ;
19527 PyObject *swig_obj[1] ;
19528
19529 if (!args) SWIG_fail;
19530 swig_obj[0] = args;
19531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19532 if (!SWIG_IsOK(res1)) {
19533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19534 }
19535 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 (arg1)->Allow();
19539 wxPyEndAllowThreads(__tstate);
19540 if (PyErr_Occurred()) SWIG_fail;
19541 }
19542 resultobj = SWIG_Py_Void();
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19550 PyObject *resultobj = 0;
19551 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19552 bool result;
19553 void *argp1 = 0 ;
19554 int res1 = 0 ;
19555 PyObject *swig_obj[1] ;
19556
19557 if (!args) SWIG_fail;
19558 swig_obj[0] = args;
19559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19560 if (!SWIG_IsOK(res1)) {
19561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19562 }
19563 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 result = (bool)(arg1)->IsAllowed();
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 {
19571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19572 }
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19580 PyObject *obj;
19581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19582 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19583 return SWIG_Py_Void();
19584 }
19585
19586 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19587 return SWIG_Python_InitShadowInstance(args);
19588 }
19589
19590 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19591 PyObject *resultobj = 0;
19592 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19593 int arg2 = (int) 0 ;
19594 int arg3 = (int) 0 ;
19595 int arg4 = (int) 0 ;
19596 wxScrollEvent *result = 0 ;
19597 int val1 ;
19598 int ecode1 = 0 ;
19599 int val2 ;
19600 int ecode2 = 0 ;
19601 int val3 ;
19602 int ecode3 = 0 ;
19603 int val4 ;
19604 int ecode4 = 0 ;
19605 PyObject * obj0 = 0 ;
19606 PyObject * obj1 = 0 ;
19607 PyObject * obj2 = 0 ;
19608 PyObject * obj3 = 0 ;
19609 char * kwnames[] = {
19610 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19611 };
19612
19613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19614 if (obj0) {
19615 ecode1 = SWIG_AsVal_int(obj0, &val1);
19616 if (!SWIG_IsOK(ecode1)) {
19617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19618 }
19619 arg1 = static_cast< wxEventType >(val1);
19620 }
19621 if (obj1) {
19622 ecode2 = SWIG_AsVal_int(obj1, &val2);
19623 if (!SWIG_IsOK(ecode2)) {
19624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19625 }
19626 arg2 = static_cast< int >(val2);
19627 }
19628 if (obj2) {
19629 ecode3 = SWIG_AsVal_int(obj2, &val3);
19630 if (!SWIG_IsOK(ecode3)) {
19631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19632 }
19633 arg3 = static_cast< int >(val3);
19634 }
19635 if (obj3) {
19636 ecode4 = SWIG_AsVal_int(obj3, &val4);
19637 if (!SWIG_IsOK(ecode4)) {
19638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19639 }
19640 arg4 = static_cast< int >(val4);
19641 }
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19656 PyObject *resultobj = 0;
19657 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19658 int result;
19659 void *argp1 = 0 ;
19660 int res1 = 0 ;
19661 PyObject *swig_obj[1] ;
19662
19663 if (!args) SWIG_fail;
19664 swig_obj[0] = args;
19665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19666 if (!SWIG_IsOK(res1)) {
19667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19668 }
19669 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19670 {
19671 PyThreadState* __tstate = wxPyBeginAllowThreads();
19672 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19673 wxPyEndAllowThreads(__tstate);
19674 if (PyErr_Occurred()) SWIG_fail;
19675 }
19676 resultobj = SWIG_From_int(static_cast< int >(result));
19677 return resultobj;
19678 fail:
19679 return NULL;
19680 }
19681
19682
19683 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19684 PyObject *resultobj = 0;
19685 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19686 int result;
19687 void *argp1 = 0 ;
19688 int res1 = 0 ;
19689 PyObject *swig_obj[1] ;
19690
19691 if (!args) SWIG_fail;
19692 swig_obj[0] = args;
19693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19694 if (!SWIG_IsOK(res1)) {
19695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19696 }
19697 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19698 {
19699 PyThreadState* __tstate = wxPyBeginAllowThreads();
19700 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 resultobj = SWIG_From_int(static_cast< int >(result));
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj = 0;
19713 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19714 int arg2 ;
19715 void *argp1 = 0 ;
19716 int res1 = 0 ;
19717 int val2 ;
19718 int ecode2 = 0 ;
19719 PyObject * obj0 = 0 ;
19720 PyObject * obj1 = 0 ;
19721 char * kwnames[] = {
19722 (char *) "self",(char *) "orient", NULL
19723 };
19724
19725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19727 if (!SWIG_IsOK(res1)) {
19728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19729 }
19730 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19731 ecode2 = SWIG_AsVal_int(obj1, &val2);
19732 if (!SWIG_IsOK(ecode2)) {
19733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19734 }
19735 arg2 = static_cast< int >(val2);
19736 {
19737 PyThreadState* __tstate = wxPyBeginAllowThreads();
19738 (arg1)->SetOrientation(arg2);
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 resultobj = SWIG_Py_Void();
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj = 0;
19751 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19752 int arg2 ;
19753 void *argp1 = 0 ;
19754 int res1 = 0 ;
19755 int val2 ;
19756 int ecode2 = 0 ;
19757 PyObject * obj0 = 0 ;
19758 PyObject * obj1 = 0 ;
19759 char * kwnames[] = {
19760 (char *) "self",(char *) "pos", NULL
19761 };
19762
19763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19765 if (!SWIG_IsOK(res1)) {
19766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19767 }
19768 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19769 ecode2 = SWIG_AsVal_int(obj1, &val2);
19770 if (!SWIG_IsOK(ecode2)) {
19771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19772 }
19773 arg2 = static_cast< int >(val2);
19774 {
19775 PyThreadState* __tstate = wxPyBeginAllowThreads();
19776 (arg1)->SetPosition(arg2);
19777 wxPyEndAllowThreads(__tstate);
19778 if (PyErr_Occurred()) SWIG_fail;
19779 }
19780 resultobj = SWIG_Py_Void();
19781 return resultobj;
19782 fail:
19783 return NULL;
19784 }
19785
19786
19787 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19788 PyObject *obj;
19789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19790 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19791 return SWIG_Py_Void();
19792 }
19793
19794 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19795 return SWIG_Python_InitShadowInstance(args);
19796 }
19797
19798 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19799 PyObject *resultobj = 0;
19800 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19801 int arg2 = (int) 0 ;
19802 int arg3 = (int) 0 ;
19803 wxScrollWinEvent *result = 0 ;
19804 int val1 ;
19805 int ecode1 = 0 ;
19806 int val2 ;
19807 int ecode2 = 0 ;
19808 int val3 ;
19809 int ecode3 = 0 ;
19810 PyObject * obj0 = 0 ;
19811 PyObject * obj1 = 0 ;
19812 PyObject * obj2 = 0 ;
19813 char * kwnames[] = {
19814 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19815 };
19816
19817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19818 if (obj0) {
19819 ecode1 = SWIG_AsVal_int(obj0, &val1);
19820 if (!SWIG_IsOK(ecode1)) {
19821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19822 }
19823 arg1 = static_cast< wxEventType >(val1);
19824 }
19825 if (obj1) {
19826 ecode2 = SWIG_AsVal_int(obj1, &val2);
19827 if (!SWIG_IsOK(ecode2)) {
19828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19829 }
19830 arg2 = static_cast< int >(val2);
19831 }
19832 if (obj2) {
19833 ecode3 = SWIG_AsVal_int(obj2, &val3);
19834 if (!SWIG_IsOK(ecode3)) {
19835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19836 }
19837 arg3 = static_cast< int >(val3);
19838 }
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19842 wxPyEndAllowThreads(__tstate);
19843 if (PyErr_Occurred()) SWIG_fail;
19844 }
19845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19846 return resultobj;
19847 fail:
19848 return NULL;
19849 }
19850
19851
19852 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19853 PyObject *resultobj = 0;
19854 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19855 int result;
19856 void *argp1 = 0 ;
19857 int res1 = 0 ;
19858 PyObject *swig_obj[1] ;
19859
19860 if (!args) SWIG_fail;
19861 swig_obj[0] = args;
19862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19863 if (!SWIG_IsOK(res1)) {
19864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19865 }
19866 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19867 {
19868 PyThreadState* __tstate = wxPyBeginAllowThreads();
19869 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19870 wxPyEndAllowThreads(__tstate);
19871 if (PyErr_Occurred()) SWIG_fail;
19872 }
19873 resultobj = SWIG_From_int(static_cast< int >(result));
19874 return resultobj;
19875 fail:
19876 return NULL;
19877 }
19878
19879
19880 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19881 PyObject *resultobj = 0;
19882 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19883 int result;
19884 void *argp1 = 0 ;
19885 int res1 = 0 ;
19886 PyObject *swig_obj[1] ;
19887
19888 if (!args) SWIG_fail;
19889 swig_obj[0] = args;
19890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19891 if (!SWIG_IsOK(res1)) {
19892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19893 }
19894 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19895 {
19896 PyThreadState* __tstate = wxPyBeginAllowThreads();
19897 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19898 wxPyEndAllowThreads(__tstate);
19899 if (PyErr_Occurred()) SWIG_fail;
19900 }
19901 resultobj = SWIG_From_int(static_cast< int >(result));
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj = 0;
19910 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19911 int arg2 ;
19912 void *argp1 = 0 ;
19913 int res1 = 0 ;
19914 int val2 ;
19915 int ecode2 = 0 ;
19916 PyObject * obj0 = 0 ;
19917 PyObject * obj1 = 0 ;
19918 char * kwnames[] = {
19919 (char *) "self",(char *) "orient", NULL
19920 };
19921
19922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19924 if (!SWIG_IsOK(res1)) {
19925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19926 }
19927 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19928 ecode2 = SWIG_AsVal_int(obj1, &val2);
19929 if (!SWIG_IsOK(ecode2)) {
19930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19931 }
19932 arg2 = static_cast< int >(val2);
19933 {
19934 PyThreadState* __tstate = wxPyBeginAllowThreads();
19935 (arg1)->SetOrientation(arg2);
19936 wxPyEndAllowThreads(__tstate);
19937 if (PyErr_Occurred()) SWIG_fail;
19938 }
19939 resultobj = SWIG_Py_Void();
19940 return resultobj;
19941 fail:
19942 return NULL;
19943 }
19944
19945
19946 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19947 PyObject *resultobj = 0;
19948 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19949 int arg2 ;
19950 void *argp1 = 0 ;
19951 int res1 = 0 ;
19952 int val2 ;
19953 int ecode2 = 0 ;
19954 PyObject * obj0 = 0 ;
19955 PyObject * obj1 = 0 ;
19956 char * kwnames[] = {
19957 (char *) "self",(char *) "pos", NULL
19958 };
19959
19960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19962 if (!SWIG_IsOK(res1)) {
19963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19964 }
19965 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19966 ecode2 = SWIG_AsVal_int(obj1, &val2);
19967 if (!SWIG_IsOK(ecode2)) {
19968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19969 }
19970 arg2 = static_cast< int >(val2);
19971 {
19972 PyThreadState* __tstate = wxPyBeginAllowThreads();
19973 (arg1)->SetPosition(arg2);
19974 wxPyEndAllowThreads(__tstate);
19975 if (PyErr_Occurred()) SWIG_fail;
19976 }
19977 resultobj = SWIG_Py_Void();
19978 return resultobj;
19979 fail:
19980 return NULL;
19981 }
19982
19983
19984 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19985 PyObject *obj;
19986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19987 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19988 return SWIG_Py_Void();
19989 }
19990
19991 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19992 return SWIG_Python_InitShadowInstance(args);
19993 }
19994
19995 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19996 PyObject *resultobj = 0;
19997 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19998 wxMouseEvent *result = 0 ;
19999 int val1 ;
20000 int ecode1 = 0 ;
20001 PyObject * obj0 = 0 ;
20002 char * kwnames[] = {
20003 (char *) "mouseType", NULL
20004 };
20005
20006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20007 if (obj0) {
20008 ecode1 = SWIG_AsVal_int(obj0, &val1);
20009 if (!SWIG_IsOK(ecode1)) {
20010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20011 }
20012 arg1 = static_cast< wxEventType >(val1);
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 {
20021 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20022 }
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20030 PyObject *resultobj = 0;
20031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20032 bool result;
20033 void *argp1 = 0 ;
20034 int res1 = 0 ;
20035 PyObject *swig_obj[1] ;
20036
20037 if (!args) SWIG_fail;
20038 swig_obj[0] = args;
20039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20040 if (!SWIG_IsOK(res1)) {
20041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20042 }
20043 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 {
20051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20052 }
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20060 PyObject *resultobj = 0;
20061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20062 int arg2 = (int) wxMOUSE_BTN_ANY ;
20063 bool result;
20064 void *argp1 = 0 ;
20065 int res1 = 0 ;
20066 int val2 ;
20067 int ecode2 = 0 ;
20068 PyObject * obj0 = 0 ;
20069 PyObject * obj1 = 0 ;
20070 char * kwnames[] = {
20071 (char *) "self",(char *) "but", NULL
20072 };
20073
20074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20076 if (!SWIG_IsOK(res1)) {
20077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20078 }
20079 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20080 if (obj1) {
20081 ecode2 = SWIG_AsVal_int(obj1, &val2);
20082 if (!SWIG_IsOK(ecode2)) {
20083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20084 }
20085 arg2 = static_cast< int >(val2);
20086 }
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 {
20094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj = 0;
20104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20105 int arg2 = (int) wxMOUSE_BTN_ANY ;
20106 bool result;
20107 void *argp1 = 0 ;
20108 int res1 = 0 ;
20109 int val2 ;
20110 int ecode2 = 0 ;
20111 PyObject * obj0 = 0 ;
20112 PyObject * obj1 = 0 ;
20113 char * kwnames[] = {
20114 (char *) "self",(char *) "but", NULL
20115 };
20116
20117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20119 if (!SWIG_IsOK(res1)) {
20120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20121 }
20122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20123 if (obj1) {
20124 ecode2 = SWIG_AsVal_int(obj1, &val2);
20125 if (!SWIG_IsOK(ecode2)) {
20126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20127 }
20128 arg2 = static_cast< int >(val2);
20129 }
20130 {
20131 PyThreadState* __tstate = wxPyBeginAllowThreads();
20132 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20133 wxPyEndAllowThreads(__tstate);
20134 if (PyErr_Occurred()) SWIG_fail;
20135 }
20136 {
20137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20138 }
20139 return resultobj;
20140 fail:
20141 return NULL;
20142 }
20143
20144
20145 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20146 PyObject *resultobj = 0;
20147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20148 int arg2 = (int) wxMOUSE_BTN_ANY ;
20149 bool result;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 int val2 ;
20153 int ecode2 = 0 ;
20154 PyObject * obj0 = 0 ;
20155 PyObject * obj1 = 0 ;
20156 char * kwnames[] = {
20157 (char *) "self",(char *) "but", NULL
20158 };
20159
20160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20162 if (!SWIG_IsOK(res1)) {
20163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20164 }
20165 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20166 if (obj1) {
20167 ecode2 = SWIG_AsVal_int(obj1, &val2);
20168 if (!SWIG_IsOK(ecode2)) {
20169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20170 }
20171 arg2 = static_cast< int >(val2);
20172 }
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 {
20180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20181 }
20182 return resultobj;
20183 fail:
20184 return NULL;
20185 }
20186
20187
20188 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20189 PyObject *resultobj = 0;
20190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20191 int arg2 ;
20192 bool result;
20193 void *argp1 = 0 ;
20194 int res1 = 0 ;
20195 int val2 ;
20196 int ecode2 = 0 ;
20197 PyObject * obj0 = 0 ;
20198 PyObject * obj1 = 0 ;
20199 char * kwnames[] = {
20200 (char *) "self",(char *) "button", NULL
20201 };
20202
20203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20205 if (!SWIG_IsOK(res1)) {
20206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20207 }
20208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20209 ecode2 = SWIG_AsVal_int(obj1, &val2);
20210 if (!SWIG_IsOK(ecode2)) {
20211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20212 }
20213 arg2 = static_cast< int >(val2);
20214 {
20215 PyThreadState* __tstate = wxPyBeginAllowThreads();
20216 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20217 wxPyEndAllowThreads(__tstate);
20218 if (PyErr_Occurred()) SWIG_fail;
20219 }
20220 {
20221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20222 }
20223 return resultobj;
20224 fail:
20225 return NULL;
20226 }
20227
20228
20229 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20230 PyObject *resultobj = 0;
20231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20232 int arg2 ;
20233 bool result;
20234 void *argp1 = 0 ;
20235 int res1 = 0 ;
20236 int val2 ;
20237 int ecode2 = 0 ;
20238 PyObject * obj0 = 0 ;
20239 PyObject * obj1 = 0 ;
20240 char * kwnames[] = {
20241 (char *) "self",(char *) "but", NULL
20242 };
20243
20244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20246 if (!SWIG_IsOK(res1)) {
20247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20248 }
20249 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20250 ecode2 = SWIG_AsVal_int(obj1, &val2);
20251 if (!SWIG_IsOK(ecode2)) {
20252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20253 }
20254 arg2 = static_cast< int >(val2);
20255 {
20256 PyThreadState* __tstate = wxPyBeginAllowThreads();
20257 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 {
20262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20263 }
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20271 PyObject *resultobj = 0;
20272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20273 int result;
20274 void *argp1 = 0 ;
20275 int res1 = 0 ;
20276 PyObject *swig_obj[1] ;
20277
20278 if (!args) SWIG_fail;
20279 swig_obj[0] = args;
20280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20281 if (!SWIG_IsOK(res1)) {
20282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20283 }
20284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20285 {
20286 PyThreadState* __tstate = wxPyBeginAllowThreads();
20287 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 resultobj = SWIG_From_int(static_cast< int >(result));
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20299 PyObject *resultobj = 0;
20300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20301 bool result;
20302 void *argp1 = 0 ;
20303 int res1 = 0 ;
20304 PyObject *swig_obj[1] ;
20305
20306 if (!args) SWIG_fail;
20307 swig_obj[0] = args;
20308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20309 if (!SWIG_IsOK(res1)) {
20310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20311 }
20312 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20316 wxPyEndAllowThreads(__tstate);
20317 if (PyErr_Occurred()) SWIG_fail;
20318 }
20319 {
20320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20321 }
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 PyObject *resultobj = 0;
20330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20331 bool result;
20332 void *argp1 = 0 ;
20333 int res1 = 0 ;
20334 PyObject *swig_obj[1] ;
20335
20336 if (!args) SWIG_fail;
20337 swig_obj[0] = args;
20338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20339 if (!SWIG_IsOK(res1)) {
20340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20341 }
20342 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20343 {
20344 PyThreadState* __tstate = wxPyBeginAllowThreads();
20345 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20346 wxPyEndAllowThreads(__tstate);
20347 if (PyErr_Occurred()) SWIG_fail;
20348 }
20349 {
20350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20351 }
20352 return resultobj;
20353 fail:
20354 return NULL;
20355 }
20356
20357
20358 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20359 PyObject *resultobj = 0;
20360 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20361 bool result;
20362 void *argp1 = 0 ;
20363 int res1 = 0 ;
20364 PyObject *swig_obj[1] ;
20365
20366 if (!args) SWIG_fail;
20367 swig_obj[0] = args;
20368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20369 if (!SWIG_IsOK(res1)) {
20370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20371 }
20372 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20373 {
20374 PyThreadState* __tstate = wxPyBeginAllowThreads();
20375 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20376 wxPyEndAllowThreads(__tstate);
20377 if (PyErr_Occurred()) SWIG_fail;
20378 }
20379 {
20380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20381 }
20382 return resultobj;
20383 fail:
20384 return NULL;
20385 }
20386
20387
20388 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20389 PyObject *resultobj = 0;
20390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20391 bool result;
20392 void *argp1 = 0 ;
20393 int res1 = 0 ;
20394 PyObject *swig_obj[1] ;
20395
20396 if (!args) SWIG_fail;
20397 swig_obj[0] = args;
20398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20399 if (!SWIG_IsOK(res1)) {
20400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20401 }
20402 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20403 {
20404 PyThreadState* __tstate = wxPyBeginAllowThreads();
20405 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20406 wxPyEndAllowThreads(__tstate);
20407 if (PyErr_Occurred()) SWIG_fail;
20408 }
20409 {
20410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20411 }
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20419 PyObject *resultobj = 0;
20420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20421 bool result;
20422 void *argp1 = 0 ;
20423 int res1 = 0 ;
20424 PyObject *swig_obj[1] ;
20425
20426 if (!args) SWIG_fail;
20427 swig_obj[0] = args;
20428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20429 if (!SWIG_IsOK(res1)) {
20430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20431 }
20432 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20433 {
20434 PyThreadState* __tstate = wxPyBeginAllowThreads();
20435 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20436 wxPyEndAllowThreads(__tstate);
20437 if (PyErr_Occurred()) SWIG_fail;
20438 }
20439 {
20440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20441 }
20442 return resultobj;
20443 fail:
20444 return NULL;
20445 }
20446
20447
20448 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20449 PyObject *resultobj = 0;
20450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20451 bool result;
20452 void *argp1 = 0 ;
20453 int res1 = 0 ;
20454 PyObject *swig_obj[1] ;
20455
20456 if (!args) SWIG_fail;
20457 swig_obj[0] = args;
20458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20459 if (!SWIG_IsOK(res1)) {
20460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20461 }
20462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20463 {
20464 PyThreadState* __tstate = wxPyBeginAllowThreads();
20465 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20466 wxPyEndAllowThreads(__tstate);
20467 if (PyErr_Occurred()) SWIG_fail;
20468 }
20469 {
20470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20471 }
20472 return resultobj;
20473 fail:
20474 return NULL;
20475 }
20476
20477
20478 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20479 PyObject *resultobj = 0;
20480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20481 bool result;
20482 void *argp1 = 0 ;
20483 int res1 = 0 ;
20484 PyObject *swig_obj[1] ;
20485
20486 if (!args) SWIG_fail;
20487 swig_obj[0] = args;
20488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20489 if (!SWIG_IsOK(res1)) {
20490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20491 }
20492 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20493 {
20494 PyThreadState* __tstate = wxPyBeginAllowThreads();
20495 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20496 wxPyEndAllowThreads(__tstate);
20497 if (PyErr_Occurred()) SWIG_fail;
20498 }
20499 {
20500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20501 }
20502 return resultobj;
20503 fail:
20504 return NULL;
20505 }
20506
20507
20508 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20509 PyObject *resultobj = 0;
20510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20511 bool result;
20512 void *argp1 = 0 ;
20513 int res1 = 0 ;
20514 PyObject *swig_obj[1] ;
20515
20516 if (!args) SWIG_fail;
20517 swig_obj[0] = args;
20518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20519 if (!SWIG_IsOK(res1)) {
20520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20521 }
20522 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 {
20530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20531 }
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20539 PyObject *resultobj = 0;
20540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20541 bool result;
20542 void *argp1 = 0 ;
20543 int res1 = 0 ;
20544 PyObject *swig_obj[1] ;
20545
20546 if (!args) SWIG_fail;
20547 swig_obj[0] = args;
20548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20549 if (!SWIG_IsOK(res1)) {
20550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20551 }
20552 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20556 wxPyEndAllowThreads(__tstate);
20557 if (PyErr_Occurred()) SWIG_fail;
20558 }
20559 {
20560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20561 }
20562 return resultobj;
20563 fail:
20564 return NULL;
20565 }
20566
20567
20568 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20569 PyObject *resultobj = 0;
20570 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20571 bool result;
20572 void *argp1 = 0 ;
20573 int res1 = 0 ;
20574 PyObject *swig_obj[1] ;
20575
20576 if (!args) SWIG_fail;
20577 swig_obj[0] = args;
20578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20579 if (!SWIG_IsOK(res1)) {
20580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20581 }
20582 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20583 {
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 {
20590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20591 }
20592 return resultobj;
20593 fail:
20594 return NULL;
20595 }
20596
20597
20598 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20599 PyObject *resultobj = 0;
20600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20601 bool result;
20602 void *argp1 = 0 ;
20603 int res1 = 0 ;
20604 PyObject *swig_obj[1] ;
20605
20606 if (!args) SWIG_fail;
20607 swig_obj[0] = args;
20608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20609 if (!SWIG_IsOK(res1)) {
20610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20611 }
20612 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20613 {
20614 PyThreadState* __tstate = wxPyBeginAllowThreads();
20615 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 {
20620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20621 }
20622 return resultobj;
20623 fail:
20624 return NULL;
20625 }
20626
20627
20628 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20629 PyObject *resultobj = 0;
20630 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20631 bool result;
20632 void *argp1 = 0 ;
20633 int res1 = 0 ;
20634 PyObject *swig_obj[1] ;
20635
20636 if (!args) SWIG_fail;
20637 swig_obj[0] = args;
20638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20639 if (!SWIG_IsOK(res1)) {
20640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20641 }
20642 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20643 {
20644 PyThreadState* __tstate = wxPyBeginAllowThreads();
20645 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20646 wxPyEndAllowThreads(__tstate);
20647 if (PyErr_Occurred()) SWIG_fail;
20648 }
20649 {
20650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20651 }
20652 return resultobj;
20653 fail:
20654 return NULL;
20655 }
20656
20657
20658 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20659 PyObject *resultobj = 0;
20660 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20661 bool result;
20662 void *argp1 = 0 ;
20663 int res1 = 0 ;
20664 PyObject *swig_obj[1] ;
20665
20666 if (!args) SWIG_fail;
20667 swig_obj[0] = args;
20668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20669 if (!SWIG_IsOK(res1)) {
20670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20671 }
20672 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 {
20680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20681 }
20682 return resultobj;
20683 fail:
20684 return NULL;
20685 }
20686
20687
20688 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20689 PyObject *resultobj = 0;
20690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20691 bool result;
20692 void *argp1 = 0 ;
20693 int res1 = 0 ;
20694 PyObject *swig_obj[1] ;
20695
20696 if (!args) SWIG_fail;
20697 swig_obj[0] = args;
20698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20699 if (!SWIG_IsOK(res1)) {
20700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20701 }
20702 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 {
20710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20711 }
20712 return resultobj;
20713 fail:
20714 return NULL;
20715 }
20716
20717
20718 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20719 PyObject *resultobj = 0;
20720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20721 bool result;
20722 void *argp1 = 0 ;
20723 int res1 = 0 ;
20724 PyObject *swig_obj[1] ;
20725
20726 if (!args) SWIG_fail;
20727 swig_obj[0] = args;
20728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20729 if (!SWIG_IsOK(res1)) {
20730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20731 }
20732 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20733 {
20734 PyThreadState* __tstate = wxPyBeginAllowThreads();
20735 result = (bool)(arg1)->LeftIsDown();
20736 wxPyEndAllowThreads(__tstate);
20737 if (PyErr_Occurred()) SWIG_fail;
20738 }
20739 {
20740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20741 }
20742 return resultobj;
20743 fail:
20744 return NULL;
20745 }
20746
20747
20748 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20749 PyObject *resultobj = 0;
20750 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20751 bool result;
20752 void *argp1 = 0 ;
20753 int res1 = 0 ;
20754 PyObject *swig_obj[1] ;
20755
20756 if (!args) SWIG_fail;
20757 swig_obj[0] = args;
20758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20759 if (!SWIG_IsOK(res1)) {
20760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20761 }
20762 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20763 {
20764 PyThreadState* __tstate = wxPyBeginAllowThreads();
20765 result = (bool)(arg1)->MiddleIsDown();
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 {
20770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20771 }
20772 return resultobj;
20773 fail:
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20779 PyObject *resultobj = 0;
20780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20781 bool result;
20782 void *argp1 = 0 ;
20783 int res1 = 0 ;
20784 PyObject *swig_obj[1] ;
20785
20786 if (!args) SWIG_fail;
20787 swig_obj[0] = args;
20788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20789 if (!SWIG_IsOK(res1)) {
20790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20791 }
20792 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = (bool)(arg1)->RightIsDown();
20796 wxPyEndAllowThreads(__tstate);
20797 if (PyErr_Occurred()) SWIG_fail;
20798 }
20799 {
20800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20801 }
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20809 PyObject *resultobj = 0;
20810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20811 bool result;
20812 void *argp1 = 0 ;
20813 int res1 = 0 ;
20814 PyObject *swig_obj[1] ;
20815
20816 if (!args) SWIG_fail;
20817 swig_obj[0] = args;
20818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20819 if (!SWIG_IsOK(res1)) {
20820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20821 }
20822 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20823 {
20824 PyThreadState* __tstate = wxPyBeginAllowThreads();
20825 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20826 wxPyEndAllowThreads(__tstate);
20827 if (PyErr_Occurred()) SWIG_fail;
20828 }
20829 {
20830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20831 }
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20839 PyObject *resultobj = 0;
20840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20841 bool result;
20842 void *argp1 = 0 ;
20843 int res1 = 0 ;
20844 PyObject *swig_obj[1] ;
20845
20846 if (!args) SWIG_fail;
20847 swig_obj[0] = args;
20848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20851 }
20852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 {
20860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20869 PyObject *resultobj = 0;
20870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20871 bool result;
20872 void *argp1 = 0 ;
20873 int res1 = 0 ;
20874 PyObject *swig_obj[1] ;
20875
20876 if (!args) SWIG_fail;
20877 swig_obj[0] = args;
20878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20879 if (!SWIG_IsOK(res1)) {
20880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20881 }
20882 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20886 wxPyEndAllowThreads(__tstate);
20887 if (PyErr_Occurred()) SWIG_fail;
20888 }
20889 {
20890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20891 }
20892 return resultobj;
20893 fail:
20894 return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20899 PyObject *resultobj = 0;
20900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20901 bool result;
20902 void *argp1 = 0 ;
20903 int res1 = 0 ;
20904 PyObject *swig_obj[1] ;
20905
20906 if (!args) SWIG_fail;
20907 swig_obj[0] = args;
20908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20909 if (!SWIG_IsOK(res1)) {
20910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20911 }
20912 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20916 wxPyEndAllowThreads(__tstate);
20917 if (PyErr_Occurred()) SWIG_fail;
20918 }
20919 {
20920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20921 }
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20929 PyObject *resultobj = 0;
20930 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20931 wxPoint result;
20932 void *argp1 = 0 ;
20933 int res1 = 0 ;
20934 PyObject *swig_obj[1] ;
20935
20936 if (!args) SWIG_fail;
20937 swig_obj[0] = args;
20938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20939 if (!SWIG_IsOK(res1)) {
20940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20941 }
20942 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 result = (arg1)->GetPosition();
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20957 PyObject *resultobj = 0;
20958 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20959 long *arg2 = (long *) 0 ;
20960 long *arg3 = (long *) 0 ;
20961 void *argp1 = 0 ;
20962 int res1 = 0 ;
20963 long temp2 ;
20964 int res2 = SWIG_TMPOBJ ;
20965 long temp3 ;
20966 int res3 = SWIG_TMPOBJ ;
20967 PyObject *swig_obj[1] ;
20968
20969 arg2 = &temp2;
20970 arg3 = &temp3;
20971 if (!args) SWIG_fail;
20972 swig_obj[0] = args;
20973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20974 if (!SWIG_IsOK(res1)) {
20975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20976 }
20977 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 (arg1)->GetPosition(arg2,arg3);
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 resultobj = SWIG_Py_Void();
20985 if (SWIG_IsTmpObj(res2)) {
20986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20987 } else {
20988 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20990 }
20991 if (SWIG_IsTmpObj(res3)) {
20992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20993 } else {
20994 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20996 }
20997 return resultobj;
20998 fail:
20999 return NULL;
21000 }
21001
21002
21003 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21004 PyObject *resultobj = 0;
21005 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21006 wxDC *arg2 = 0 ;
21007 wxPoint result;
21008 void *argp1 = 0 ;
21009 int res1 = 0 ;
21010 void *argp2 = 0 ;
21011 int res2 = 0 ;
21012 PyObject * obj0 = 0 ;
21013 PyObject * obj1 = 0 ;
21014 char * kwnames[] = {
21015 (char *) "self",(char *) "dc", NULL
21016 };
21017
21018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21020 if (!SWIG_IsOK(res1)) {
21021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21022 }
21023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21025 if (!SWIG_IsOK(res2)) {
21026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21027 }
21028 if (!argp2) {
21029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21030 }
21031 arg2 = reinterpret_cast< wxDC * >(argp2);
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *resultobj = 0;
21047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21048 int result;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 PyObject *swig_obj[1] ;
21052
21053 if (!args) SWIG_fail;
21054 swig_obj[0] = args;
21055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21056 if (!SWIG_IsOK(res1)) {
21057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21058 }
21059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (int)((wxMouseEvent const *)arg1)->GetX();
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 resultobj = SWIG_From_int(static_cast< int >(result));
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21074 PyObject *resultobj = 0;
21075 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21076 int result;
21077 void *argp1 = 0 ;
21078 int res1 = 0 ;
21079 PyObject *swig_obj[1] ;
21080
21081 if (!args) SWIG_fail;
21082 swig_obj[0] = args;
21083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21084 if (!SWIG_IsOK(res1)) {
21085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21086 }
21087 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21088 {
21089 PyThreadState* __tstate = wxPyBeginAllowThreads();
21090 result = (int)((wxMouseEvent const *)arg1)->GetY();
21091 wxPyEndAllowThreads(__tstate);
21092 if (PyErr_Occurred()) SWIG_fail;
21093 }
21094 resultobj = SWIG_From_int(static_cast< int >(result));
21095 return resultobj;
21096 fail:
21097 return NULL;
21098 }
21099
21100
21101 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21102 PyObject *resultobj = 0;
21103 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21104 int result;
21105 void *argp1 = 0 ;
21106 int res1 = 0 ;
21107 PyObject *swig_obj[1] ;
21108
21109 if (!args) SWIG_fail;
21110 swig_obj[0] = args;
21111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21112 if (!SWIG_IsOK(res1)) {
21113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21114 }
21115 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21119 wxPyEndAllowThreads(__tstate);
21120 if (PyErr_Occurred()) SWIG_fail;
21121 }
21122 resultobj = SWIG_From_int(static_cast< int >(result));
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 PyObject *resultobj = 0;
21131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21132 int result;
21133 void *argp1 = 0 ;
21134 int res1 = 0 ;
21135 PyObject *swig_obj[1] ;
21136
21137 if (!args) SWIG_fail;
21138 swig_obj[0] = args;
21139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21140 if (!SWIG_IsOK(res1)) {
21141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21142 }
21143 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 resultobj = SWIG_From_int(static_cast< int >(result));
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21158 PyObject *resultobj = 0;
21159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21160 int result;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 PyObject *swig_obj[1] ;
21164
21165 if (!args) SWIG_fail;
21166 swig_obj[0] = args;
21167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21168 if (!SWIG_IsOK(res1)) {
21169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21170 }
21171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 resultobj = SWIG_From_int(static_cast< int >(result));
21179 return resultobj;
21180 fail:
21181 return NULL;
21182 }
21183
21184
21185 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21186 PyObject *resultobj = 0;
21187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21188 bool result;
21189 void *argp1 = 0 ;
21190 int res1 = 0 ;
21191 PyObject *swig_obj[1] ;
21192
21193 if (!args) SWIG_fail;
21194 swig_obj[0] = args;
21195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21196 if (!SWIG_IsOK(res1)) {
21197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21198 }
21199 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21203 wxPyEndAllowThreads(__tstate);
21204 if (PyErr_Occurred()) SWIG_fail;
21205 }
21206 {
21207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21208 }
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21216 PyObject *resultobj = 0;
21217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21218 int arg2 ;
21219 void *argp1 = 0 ;
21220 int res1 = 0 ;
21221 int val2 ;
21222 int ecode2 = 0 ;
21223 PyObject *swig_obj[2] ;
21224
21225 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21227 if (!SWIG_IsOK(res1)) {
21228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21229 }
21230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21231 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21232 if (!SWIG_IsOK(ecode2)) {
21233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21234 }
21235 arg2 = static_cast< int >(val2);
21236 if (arg1) (arg1)->m_x = arg2;
21237
21238 resultobj = SWIG_Py_Void();
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21246 PyObject *resultobj = 0;
21247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21248 int result;
21249 void *argp1 = 0 ;
21250 int res1 = 0 ;
21251 PyObject *swig_obj[1] ;
21252
21253 if (!args) SWIG_fail;
21254 swig_obj[0] = args;
21255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21256 if (!SWIG_IsOK(res1)) {
21257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21258 }
21259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21260 result = (int) ((arg1)->m_x);
21261 resultobj = SWIG_From_int(static_cast< int >(result));
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21269 PyObject *resultobj = 0;
21270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21271 int arg2 ;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 int val2 ;
21275 int ecode2 = 0 ;
21276 PyObject *swig_obj[2] ;
21277
21278 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21280 if (!SWIG_IsOK(res1)) {
21281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21282 }
21283 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21284 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21285 if (!SWIG_IsOK(ecode2)) {
21286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21287 }
21288 arg2 = static_cast< int >(val2);
21289 if (arg1) (arg1)->m_y = arg2;
21290
21291 resultobj = SWIG_Py_Void();
21292 return resultobj;
21293 fail:
21294 return NULL;
21295 }
21296
21297
21298 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21299 PyObject *resultobj = 0;
21300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21301 int result;
21302 void *argp1 = 0 ;
21303 int res1 = 0 ;
21304 PyObject *swig_obj[1] ;
21305
21306 if (!args) SWIG_fail;
21307 swig_obj[0] = args;
21308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21311 }
21312 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21313 result = (int) ((arg1)->m_y);
21314 resultobj = SWIG_From_int(static_cast< int >(result));
21315 return resultobj;
21316 fail:
21317 return NULL;
21318 }
21319
21320
21321 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21322 PyObject *resultobj = 0;
21323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21324 bool arg2 ;
21325 void *argp1 = 0 ;
21326 int res1 = 0 ;
21327 bool val2 ;
21328 int ecode2 = 0 ;
21329 PyObject *swig_obj[2] ;
21330
21331 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21333 if (!SWIG_IsOK(res1)) {
21334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21335 }
21336 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21337 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21338 if (!SWIG_IsOK(ecode2)) {
21339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21340 }
21341 arg2 = static_cast< bool >(val2);
21342 if (arg1) (arg1)->m_leftDown = arg2;
21343
21344 resultobj = SWIG_Py_Void();
21345 return resultobj;
21346 fail:
21347 return NULL;
21348 }
21349
21350
21351 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21352 PyObject *resultobj = 0;
21353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21354 bool result;
21355 void *argp1 = 0 ;
21356 int res1 = 0 ;
21357 PyObject *swig_obj[1] ;
21358
21359 if (!args) SWIG_fail;
21360 swig_obj[0] = args;
21361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21362 if (!SWIG_IsOK(res1)) {
21363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21364 }
21365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21366 result = (bool) ((arg1)->m_leftDown);
21367 {
21368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21369 }
21370 return resultobj;
21371 fail:
21372 return NULL;
21373 }
21374
21375
21376 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21377 PyObject *resultobj = 0;
21378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21379 bool arg2 ;
21380 void *argp1 = 0 ;
21381 int res1 = 0 ;
21382 bool val2 ;
21383 int ecode2 = 0 ;
21384 PyObject *swig_obj[2] ;
21385
21386 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21390 }
21391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21392 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21393 if (!SWIG_IsOK(ecode2)) {
21394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21395 }
21396 arg2 = static_cast< bool >(val2);
21397 if (arg1) (arg1)->m_middleDown = arg2;
21398
21399 resultobj = SWIG_Py_Void();
21400 return resultobj;
21401 fail:
21402 return NULL;
21403 }
21404
21405
21406 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21407 PyObject *resultobj = 0;
21408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21409 bool result;
21410 void *argp1 = 0 ;
21411 int res1 = 0 ;
21412 PyObject *swig_obj[1] ;
21413
21414 if (!args) SWIG_fail;
21415 swig_obj[0] = args;
21416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21417 if (!SWIG_IsOK(res1)) {
21418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21419 }
21420 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21421 result = (bool) ((arg1)->m_middleDown);
21422 {
21423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21424 }
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21432 PyObject *resultobj = 0;
21433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21434 bool arg2 ;
21435 void *argp1 = 0 ;
21436 int res1 = 0 ;
21437 bool val2 ;
21438 int ecode2 = 0 ;
21439 PyObject *swig_obj[2] ;
21440
21441 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21445 }
21446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21447 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21448 if (!SWIG_IsOK(ecode2)) {
21449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21450 }
21451 arg2 = static_cast< bool >(val2);
21452 if (arg1) (arg1)->m_rightDown = arg2;
21453
21454 resultobj = SWIG_Py_Void();
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21462 PyObject *resultobj = 0;
21463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21464 bool result;
21465 void *argp1 = 0 ;
21466 int res1 = 0 ;
21467 PyObject *swig_obj[1] ;
21468
21469 if (!args) SWIG_fail;
21470 swig_obj[0] = args;
21471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21472 if (!SWIG_IsOK(res1)) {
21473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21474 }
21475 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21476 result = (bool) ((arg1)->m_rightDown);
21477 {
21478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21479 }
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21487 PyObject *resultobj = 0;
21488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21489 bool arg2 ;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 bool val2 ;
21493 int ecode2 = 0 ;
21494 PyObject *swig_obj[2] ;
21495
21496 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21498 if (!SWIG_IsOK(res1)) {
21499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21500 }
21501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21502 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21503 if (!SWIG_IsOK(ecode2)) {
21504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21505 }
21506 arg2 = static_cast< bool >(val2);
21507 if (arg1) (arg1)->m_controlDown = arg2;
21508
21509 resultobj = SWIG_Py_Void();
21510 return resultobj;
21511 fail:
21512 return NULL;
21513 }
21514
21515
21516 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21517 PyObject *resultobj = 0;
21518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21519 bool result;
21520 void *argp1 = 0 ;
21521 int res1 = 0 ;
21522 PyObject *swig_obj[1] ;
21523
21524 if (!args) SWIG_fail;
21525 swig_obj[0] = args;
21526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21527 if (!SWIG_IsOK(res1)) {
21528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21529 }
21530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21531 result = (bool) ((arg1)->m_controlDown);
21532 {
21533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21534 }
21535 return resultobj;
21536 fail:
21537 return NULL;
21538 }
21539
21540
21541 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21542 PyObject *resultobj = 0;
21543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21544 bool arg2 ;
21545 void *argp1 = 0 ;
21546 int res1 = 0 ;
21547 bool val2 ;
21548 int ecode2 = 0 ;
21549 PyObject *swig_obj[2] ;
21550
21551 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21553 if (!SWIG_IsOK(res1)) {
21554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21555 }
21556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21557 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21558 if (!SWIG_IsOK(ecode2)) {
21559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21560 }
21561 arg2 = static_cast< bool >(val2);
21562 if (arg1) (arg1)->m_shiftDown = arg2;
21563
21564 resultobj = SWIG_Py_Void();
21565 return resultobj;
21566 fail:
21567 return NULL;
21568 }
21569
21570
21571 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21572 PyObject *resultobj = 0;
21573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21574 bool result;
21575 void *argp1 = 0 ;
21576 int res1 = 0 ;
21577 PyObject *swig_obj[1] ;
21578
21579 if (!args) SWIG_fail;
21580 swig_obj[0] = args;
21581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21582 if (!SWIG_IsOK(res1)) {
21583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21584 }
21585 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21586 result = (bool) ((arg1)->m_shiftDown);
21587 {
21588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21589 }
21590 return resultobj;
21591 fail:
21592 return NULL;
21593 }
21594
21595
21596 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21597 PyObject *resultobj = 0;
21598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21599 bool arg2 ;
21600 void *argp1 = 0 ;
21601 int res1 = 0 ;
21602 bool val2 ;
21603 int ecode2 = 0 ;
21604 PyObject *swig_obj[2] ;
21605
21606 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21608 if (!SWIG_IsOK(res1)) {
21609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21610 }
21611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21612 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21613 if (!SWIG_IsOK(ecode2)) {
21614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21615 }
21616 arg2 = static_cast< bool >(val2);
21617 if (arg1) (arg1)->m_altDown = arg2;
21618
21619 resultobj = SWIG_Py_Void();
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21627 PyObject *resultobj = 0;
21628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21629 bool result;
21630 void *argp1 = 0 ;
21631 int res1 = 0 ;
21632 PyObject *swig_obj[1] ;
21633
21634 if (!args) SWIG_fail;
21635 swig_obj[0] = args;
21636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21637 if (!SWIG_IsOK(res1)) {
21638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21639 }
21640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21641 result = (bool) ((arg1)->m_altDown);
21642 {
21643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21644 }
21645 return resultobj;
21646 fail:
21647 return NULL;
21648 }
21649
21650
21651 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21652 PyObject *resultobj = 0;
21653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21654 bool arg2 ;
21655 void *argp1 = 0 ;
21656 int res1 = 0 ;
21657 bool val2 ;
21658 int ecode2 = 0 ;
21659 PyObject *swig_obj[2] ;
21660
21661 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21663 if (!SWIG_IsOK(res1)) {
21664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21665 }
21666 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21667 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21668 if (!SWIG_IsOK(ecode2)) {
21669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21670 }
21671 arg2 = static_cast< bool >(val2);
21672 if (arg1) (arg1)->m_metaDown = arg2;
21673
21674 resultobj = SWIG_Py_Void();
21675 return resultobj;
21676 fail:
21677 return NULL;
21678 }
21679
21680
21681 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21682 PyObject *resultobj = 0;
21683 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21684 bool result;
21685 void *argp1 = 0 ;
21686 int res1 = 0 ;
21687 PyObject *swig_obj[1] ;
21688
21689 if (!args) SWIG_fail;
21690 swig_obj[0] = args;
21691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21692 if (!SWIG_IsOK(res1)) {
21693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21694 }
21695 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21696 result = (bool) ((arg1)->m_metaDown);
21697 {
21698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21699 }
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21707 PyObject *resultobj = 0;
21708 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21709 int arg2 ;
21710 void *argp1 = 0 ;
21711 int res1 = 0 ;
21712 int val2 ;
21713 int ecode2 = 0 ;
21714 PyObject *swig_obj[2] ;
21715
21716 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21718 if (!SWIG_IsOK(res1)) {
21719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21720 }
21721 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21722 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21723 if (!SWIG_IsOK(ecode2)) {
21724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21725 }
21726 arg2 = static_cast< int >(val2);
21727 if (arg1) (arg1)->m_wheelRotation = arg2;
21728
21729 resultobj = SWIG_Py_Void();
21730 return resultobj;
21731 fail:
21732 return NULL;
21733 }
21734
21735
21736 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21737 PyObject *resultobj = 0;
21738 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21739 int result;
21740 void *argp1 = 0 ;
21741 int res1 = 0 ;
21742 PyObject *swig_obj[1] ;
21743
21744 if (!args) SWIG_fail;
21745 swig_obj[0] = args;
21746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21747 if (!SWIG_IsOK(res1)) {
21748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21749 }
21750 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21751 result = (int) ((arg1)->m_wheelRotation);
21752 resultobj = SWIG_From_int(static_cast< int >(result));
21753 return resultobj;
21754 fail:
21755 return NULL;
21756 }
21757
21758
21759 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21760 PyObject *resultobj = 0;
21761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21762 int arg2 ;
21763 void *argp1 = 0 ;
21764 int res1 = 0 ;
21765 int val2 ;
21766 int ecode2 = 0 ;
21767 PyObject *swig_obj[2] ;
21768
21769 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21771 if (!SWIG_IsOK(res1)) {
21772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21773 }
21774 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21775 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21776 if (!SWIG_IsOK(ecode2)) {
21777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21778 }
21779 arg2 = static_cast< int >(val2);
21780 if (arg1) (arg1)->m_wheelDelta = arg2;
21781
21782 resultobj = SWIG_Py_Void();
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21790 PyObject *resultobj = 0;
21791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21792 int result;
21793 void *argp1 = 0 ;
21794 int res1 = 0 ;
21795 PyObject *swig_obj[1] ;
21796
21797 if (!args) SWIG_fail;
21798 swig_obj[0] = args;
21799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21800 if (!SWIG_IsOK(res1)) {
21801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21802 }
21803 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21804 result = (int) ((arg1)->m_wheelDelta);
21805 resultobj = SWIG_From_int(static_cast< int >(result));
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 PyObject *resultobj = 0;
21814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21815 int arg2 ;
21816 void *argp1 = 0 ;
21817 int res1 = 0 ;
21818 int val2 ;
21819 int ecode2 = 0 ;
21820 PyObject *swig_obj[2] ;
21821
21822 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21824 if (!SWIG_IsOK(res1)) {
21825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21826 }
21827 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21828 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21829 if (!SWIG_IsOK(ecode2)) {
21830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21831 }
21832 arg2 = static_cast< int >(val2);
21833 if (arg1) (arg1)->m_linesPerAction = arg2;
21834
21835 resultobj = SWIG_Py_Void();
21836 return resultobj;
21837 fail:
21838 return NULL;
21839 }
21840
21841
21842 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21843 PyObject *resultobj = 0;
21844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21845 int result;
21846 void *argp1 = 0 ;
21847 int res1 = 0 ;
21848 PyObject *swig_obj[1] ;
21849
21850 if (!args) SWIG_fail;
21851 swig_obj[0] = args;
21852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21853 if (!SWIG_IsOK(res1)) {
21854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21855 }
21856 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21857 result = (int) ((arg1)->m_linesPerAction);
21858 resultobj = SWIG_From_int(static_cast< int >(result));
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21866 PyObject *obj;
21867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21868 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21869 return SWIG_Py_Void();
21870 }
21871
21872 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21873 return SWIG_Python_InitShadowInstance(args);
21874 }
21875
21876 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21877 PyObject *resultobj = 0;
21878 int arg1 = (int) 0 ;
21879 int arg2 = (int) 0 ;
21880 wxSetCursorEvent *result = 0 ;
21881 int val1 ;
21882 int ecode1 = 0 ;
21883 int val2 ;
21884 int ecode2 = 0 ;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 char * kwnames[] = {
21888 (char *) "x",(char *) "y", NULL
21889 };
21890
21891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21892 if (obj0) {
21893 ecode1 = SWIG_AsVal_int(obj0, &val1);
21894 if (!SWIG_IsOK(ecode1)) {
21895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21896 }
21897 arg1 = static_cast< int >(val1);
21898 }
21899 if (obj1) {
21900 ecode2 = SWIG_AsVal_int(obj1, &val2);
21901 if (!SWIG_IsOK(ecode2)) {
21902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21903 }
21904 arg2 = static_cast< int >(val2);
21905 }
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21920 PyObject *resultobj = 0;
21921 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21922 int result;
21923 void *argp1 = 0 ;
21924 int res1 = 0 ;
21925 PyObject *swig_obj[1] ;
21926
21927 if (!args) SWIG_fail;
21928 swig_obj[0] = args;
21929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21930 if (!SWIG_IsOK(res1)) {
21931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21932 }
21933 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 resultobj = SWIG_From_int(static_cast< int >(result));
21941 return resultobj;
21942 fail:
21943 return NULL;
21944 }
21945
21946
21947 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21948 PyObject *resultobj = 0;
21949 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21950 int result;
21951 void *argp1 = 0 ;
21952 int res1 = 0 ;
21953 PyObject *swig_obj[1] ;
21954
21955 if (!args) SWIG_fail;
21956 swig_obj[0] = args;
21957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21958 if (!SWIG_IsOK(res1)) {
21959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21960 }
21961 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21962 {
21963 PyThreadState* __tstate = wxPyBeginAllowThreads();
21964 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 resultobj = SWIG_From_int(static_cast< int >(result));
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21976 PyObject *resultobj = 0;
21977 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21978 wxCursor *arg2 = 0 ;
21979 void *argp1 = 0 ;
21980 int res1 = 0 ;
21981 void *argp2 = 0 ;
21982 int res2 = 0 ;
21983 PyObject * obj0 = 0 ;
21984 PyObject * obj1 = 0 ;
21985 char * kwnames[] = {
21986 (char *) "self",(char *) "cursor", NULL
21987 };
21988
21989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21991 if (!SWIG_IsOK(res1)) {
21992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21993 }
21994 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21995 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21996 if (!SWIG_IsOK(res2)) {
21997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21998 }
21999 if (!argp2) {
22000 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22001 }
22002 arg2 = reinterpret_cast< wxCursor * >(argp2);
22003 {
22004 PyThreadState* __tstate = wxPyBeginAllowThreads();
22005 (arg1)->SetCursor((wxCursor const &)*arg2);
22006 wxPyEndAllowThreads(__tstate);
22007 if (PyErr_Occurred()) SWIG_fail;
22008 }
22009 resultobj = SWIG_Py_Void();
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22017 PyObject *resultobj = 0;
22018 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22019 wxCursor *result = 0 ;
22020 void *argp1 = 0 ;
22021 int res1 = 0 ;
22022 PyObject *swig_obj[1] ;
22023
22024 if (!args) SWIG_fail;
22025 swig_obj[0] = args;
22026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22027 if (!SWIG_IsOK(res1)) {
22028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22029 }
22030 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22031 {
22032 PyThreadState* __tstate = wxPyBeginAllowThreads();
22033 {
22034 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22035 result = (wxCursor *) &_result_ref;
22036 }
22037 wxPyEndAllowThreads(__tstate);
22038 if (PyErr_Occurred()) SWIG_fail;
22039 }
22040 {
22041 wxCursor* resultptr = new wxCursor(*result);
22042 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22043 }
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22053 bool result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22063 }
22064 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 {
22072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22073 }
22074 return resultobj;
22075 fail:
22076 return NULL;
22077 }
22078
22079
22080 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22081 PyObject *obj;
22082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22083 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22084 return SWIG_Py_Void();
22085 }
22086
22087 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22088 return SWIG_Python_InitShadowInstance(args);
22089 }
22090
22091 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22092 PyObject *resultobj = 0;
22093 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22094 wxKeyEvent *result = 0 ;
22095 int val1 ;
22096 int ecode1 = 0 ;
22097 PyObject * obj0 = 0 ;
22098 char * kwnames[] = {
22099 (char *) "eventType", NULL
22100 };
22101
22102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22103 if (obj0) {
22104 ecode1 = SWIG_AsVal_int(obj0, &val1);
22105 if (!SWIG_IsOK(ecode1)) {
22106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22107 }
22108 arg1 = static_cast< wxEventType >(val1);
22109 }
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22117 return resultobj;
22118 fail:
22119 return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22126 int result;
22127 void *argp1 = 0 ;
22128 int res1 = 0 ;
22129 PyObject *swig_obj[1] ;
22130
22131 if (!args) SWIG_fail;
22132 swig_obj[0] = args;
22133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22136 }
22137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 resultobj = SWIG_From_int(static_cast< int >(result));
22145 return resultobj;
22146 fail:
22147 return NULL;
22148 }
22149
22150
22151 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22152 PyObject *resultobj = 0;
22153 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22154 bool result;
22155 void *argp1 = 0 ;
22156 int res1 = 0 ;
22157 PyObject *swig_obj[1] ;
22158
22159 if (!args) SWIG_fail;
22160 swig_obj[0] = args;
22161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22162 if (!SWIG_IsOK(res1)) {
22163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22164 }
22165 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22169 wxPyEndAllowThreads(__tstate);
22170 if (PyErr_Occurred()) SWIG_fail;
22171 }
22172 {
22173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22174 }
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22184 bool result;
22185 void *argp1 = 0 ;
22186 int res1 = 0 ;
22187 PyObject *swig_obj[1] ;
22188
22189 if (!args) SWIG_fail;
22190 swig_obj[0] = args;
22191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22192 if (!SWIG_IsOK(res1)) {
22193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22194 }
22195 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 {
22203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22204 }
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22212 PyObject *resultobj = 0;
22213 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22214 bool result;
22215 void *argp1 = 0 ;
22216 int res1 = 0 ;
22217 PyObject *swig_obj[1] ;
22218
22219 if (!args) SWIG_fail;
22220 swig_obj[0] = args;
22221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22222 if (!SWIG_IsOK(res1)) {
22223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22224 }
22225 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22226 {
22227 PyThreadState* __tstate = wxPyBeginAllowThreads();
22228 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22229 wxPyEndAllowThreads(__tstate);
22230 if (PyErr_Occurred()) SWIG_fail;
22231 }
22232 {
22233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22234 }
22235 return resultobj;
22236 fail:
22237 return NULL;
22238 }
22239
22240
22241 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22242 PyObject *resultobj = 0;
22243 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22244 bool result;
22245 void *argp1 = 0 ;
22246 int res1 = 0 ;
22247 PyObject *swig_obj[1] ;
22248
22249 if (!args) SWIG_fail;
22250 swig_obj[0] = args;
22251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22252 if (!SWIG_IsOK(res1)) {
22253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22254 }
22255 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 {
22263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22264 }
22265 return resultobj;
22266 fail:
22267 return NULL;
22268 }
22269
22270
22271 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22272 PyObject *resultobj = 0;
22273 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22274 bool result;
22275 void *argp1 = 0 ;
22276 int res1 = 0 ;
22277 PyObject *swig_obj[1] ;
22278
22279 if (!args) SWIG_fail;
22280 swig_obj[0] = args;
22281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22282 if (!SWIG_IsOK(res1)) {
22283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22284 }
22285 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 {
22293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22294 }
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22302 PyObject *resultobj = 0;
22303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22304 bool result;
22305 void *argp1 = 0 ;
22306 int res1 = 0 ;
22307 PyObject *swig_obj[1] ;
22308
22309 if (!args) SWIG_fail;
22310 swig_obj[0] = args;
22311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22312 if (!SWIG_IsOK(res1)) {
22313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22314 }
22315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 {
22323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22324 }
22325 return resultobj;
22326 fail:
22327 return NULL;
22328 }
22329
22330
22331 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22332 PyObject *resultobj = 0;
22333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22334 int result;
22335 void *argp1 = 0 ;
22336 int res1 = 0 ;
22337 PyObject *swig_obj[1] ;
22338
22339 if (!args) SWIG_fail;
22340 swig_obj[0] = args;
22341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22342 if (!SWIG_IsOK(res1)) {
22343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22344 }
22345 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22346 {
22347 PyThreadState* __tstate = wxPyBeginAllowThreads();
22348 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22349 wxPyEndAllowThreads(__tstate);
22350 if (PyErr_Occurred()) SWIG_fail;
22351 }
22352 resultobj = SWIG_From_int(static_cast< int >(result));
22353 return resultobj;
22354 fail:
22355 return NULL;
22356 }
22357
22358
22359 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22360 PyObject *resultobj = 0;
22361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22362 int result;
22363 void *argp1 = 0 ;
22364 int res1 = 0 ;
22365 PyObject *swig_obj[1] ;
22366
22367 if (!args) SWIG_fail;
22368 swig_obj[0] = args;
22369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22370 if (!SWIG_IsOK(res1)) {
22371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22372 }
22373 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 resultobj = SWIG_From_int(static_cast< int >(result));
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22388 PyObject *resultobj = 0;
22389 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22390 int arg2 ;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 int val2 ;
22394 int ecode2 = 0 ;
22395 PyObject * obj0 = 0 ;
22396 PyObject * obj1 = 0 ;
22397 char * kwnames[] = {
22398 (char *) "self",(char *) "uniChar", NULL
22399 };
22400
22401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22403 if (!SWIG_IsOK(res1)) {
22404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22405 }
22406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22407 ecode2 = SWIG_AsVal_int(obj1, &val2);
22408 if (!SWIG_IsOK(ecode2)) {
22409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22410 }
22411 arg2 = static_cast< int >(val2);
22412 {
22413 PyThreadState* __tstate = wxPyBeginAllowThreads();
22414 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22415 wxPyEndAllowThreads(__tstate);
22416 if (PyErr_Occurred()) SWIG_fail;
22417 }
22418 resultobj = SWIG_Py_Void();
22419 return resultobj;
22420 fail:
22421 return NULL;
22422 }
22423
22424
22425 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22426 PyObject *resultobj = 0;
22427 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22428 unsigned int result;
22429 void *argp1 = 0 ;
22430 int res1 = 0 ;
22431 PyObject *swig_obj[1] ;
22432
22433 if (!args) SWIG_fail;
22434 swig_obj[0] = args;
22435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22436 if (!SWIG_IsOK(res1)) {
22437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22438 }
22439 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22440 {
22441 PyThreadState* __tstate = wxPyBeginAllowThreads();
22442 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22443 wxPyEndAllowThreads(__tstate);
22444 if (PyErr_Occurred()) SWIG_fail;
22445 }
22446 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22447 return resultobj;
22448 fail:
22449 return NULL;
22450 }
22451
22452
22453 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22454 PyObject *resultobj = 0;
22455 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22456 unsigned int result;
22457 void *argp1 = 0 ;
22458 int res1 = 0 ;
22459 PyObject *swig_obj[1] ;
22460
22461 if (!args) SWIG_fail;
22462 swig_obj[0] = args;
22463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22464 if (!SWIG_IsOK(res1)) {
22465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22466 }
22467 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22468 {
22469 PyThreadState* __tstate = wxPyBeginAllowThreads();
22470 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22471 wxPyEndAllowThreads(__tstate);
22472 if (PyErr_Occurred()) SWIG_fail;
22473 }
22474 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22475 return resultobj;
22476 fail:
22477 return NULL;
22478 }
22479
22480
22481 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22482 PyObject *resultobj = 0;
22483 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22484 wxPoint result;
22485 void *argp1 = 0 ;
22486 int res1 = 0 ;
22487 PyObject *swig_obj[1] ;
22488
22489 if (!args) SWIG_fail;
22490 swig_obj[0] = args;
22491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22492 if (!SWIG_IsOK(res1)) {
22493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22494 }
22495 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22496 {
22497 PyThreadState* __tstate = wxPyBeginAllowThreads();
22498 result = (arg1)->GetPosition();
22499 wxPyEndAllowThreads(__tstate);
22500 if (PyErr_Occurred()) SWIG_fail;
22501 }
22502 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22510 PyObject *resultobj = 0;
22511 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22512 long *arg2 = (long *) 0 ;
22513 long *arg3 = (long *) 0 ;
22514 void *argp1 = 0 ;
22515 int res1 = 0 ;
22516 long temp2 ;
22517 int res2 = SWIG_TMPOBJ ;
22518 long temp3 ;
22519 int res3 = SWIG_TMPOBJ ;
22520 PyObject *swig_obj[1] ;
22521
22522 arg2 = &temp2;
22523 arg3 = &temp3;
22524 if (!args) SWIG_fail;
22525 swig_obj[0] = args;
22526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22527 if (!SWIG_IsOK(res1)) {
22528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22529 }
22530 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22531 {
22532 PyThreadState* __tstate = wxPyBeginAllowThreads();
22533 (arg1)->GetPosition(arg2,arg3);
22534 wxPyEndAllowThreads(__tstate);
22535 if (PyErr_Occurred()) SWIG_fail;
22536 }
22537 resultobj = SWIG_Py_Void();
22538 if (SWIG_IsTmpObj(res2)) {
22539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22540 } else {
22541 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22543 }
22544 if (SWIG_IsTmpObj(res3)) {
22545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22546 } else {
22547 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22549 }
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22557 PyObject *resultobj = 0;
22558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22559 int result;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 PyObject *swig_obj[1] ;
22563
22564 if (!args) SWIG_fail;
22565 swig_obj[0] = args;
22566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22567 if (!SWIG_IsOK(res1)) {
22568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22569 }
22570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22571 {
22572 PyThreadState* __tstate = wxPyBeginAllowThreads();
22573 result = (int)((wxKeyEvent const *)arg1)->GetX();
22574 wxPyEndAllowThreads(__tstate);
22575 if (PyErr_Occurred()) SWIG_fail;
22576 }
22577 resultobj = SWIG_From_int(static_cast< int >(result));
22578 return resultobj;
22579 fail:
22580 return NULL;
22581 }
22582
22583
22584 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22585 PyObject *resultobj = 0;
22586 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22587 int result;
22588 void *argp1 = 0 ;
22589 int res1 = 0 ;
22590 PyObject *swig_obj[1] ;
22591
22592 if (!args) SWIG_fail;
22593 swig_obj[0] = args;
22594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22595 if (!SWIG_IsOK(res1)) {
22596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22597 }
22598 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22599 {
22600 PyThreadState* __tstate = wxPyBeginAllowThreads();
22601 result = (int)((wxKeyEvent const *)arg1)->GetY();
22602 wxPyEndAllowThreads(__tstate);
22603 if (PyErr_Occurred()) SWIG_fail;
22604 }
22605 resultobj = SWIG_From_int(static_cast< int >(result));
22606 return resultobj;
22607 fail:
22608 return NULL;
22609 }
22610
22611
22612 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22613 PyObject *resultobj = 0;
22614 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22615 int arg2 ;
22616 void *argp1 = 0 ;
22617 int res1 = 0 ;
22618 int val2 ;
22619 int ecode2 = 0 ;
22620 PyObject *swig_obj[2] ;
22621
22622 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22624 if (!SWIG_IsOK(res1)) {
22625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22626 }
22627 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22628 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22629 if (!SWIG_IsOK(ecode2)) {
22630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22631 }
22632 arg2 = static_cast< int >(val2);
22633 if (arg1) (arg1)->m_x = arg2;
22634
22635 resultobj = SWIG_Py_Void();
22636 return resultobj;
22637 fail:
22638 return NULL;
22639 }
22640
22641
22642 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22643 PyObject *resultobj = 0;
22644 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22645 int result;
22646 void *argp1 = 0 ;
22647 int res1 = 0 ;
22648 PyObject *swig_obj[1] ;
22649
22650 if (!args) SWIG_fail;
22651 swig_obj[0] = args;
22652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22653 if (!SWIG_IsOK(res1)) {
22654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22655 }
22656 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22657 result = (int) ((arg1)->m_x);
22658 resultobj = SWIG_From_int(static_cast< int >(result));
22659 return resultobj;
22660 fail:
22661 return NULL;
22662 }
22663
22664
22665 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22666 PyObject *resultobj = 0;
22667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22668 int arg2 ;
22669 void *argp1 = 0 ;
22670 int res1 = 0 ;
22671 int val2 ;
22672 int ecode2 = 0 ;
22673 PyObject *swig_obj[2] ;
22674
22675 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22677 if (!SWIG_IsOK(res1)) {
22678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22679 }
22680 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22681 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22682 if (!SWIG_IsOK(ecode2)) {
22683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22684 }
22685 arg2 = static_cast< int >(val2);
22686 if (arg1) (arg1)->m_y = arg2;
22687
22688 resultobj = SWIG_Py_Void();
22689 return resultobj;
22690 fail:
22691 return NULL;
22692 }
22693
22694
22695 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22696 PyObject *resultobj = 0;
22697 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22698 int result;
22699 void *argp1 = 0 ;
22700 int res1 = 0 ;
22701 PyObject *swig_obj[1] ;
22702
22703 if (!args) SWIG_fail;
22704 swig_obj[0] = args;
22705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22706 if (!SWIG_IsOK(res1)) {
22707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22708 }
22709 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22710 result = (int) ((arg1)->m_y);
22711 resultobj = SWIG_From_int(static_cast< int >(result));
22712 return resultobj;
22713 fail:
22714 return NULL;
22715 }
22716
22717
22718 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22719 PyObject *resultobj = 0;
22720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22721 long arg2 ;
22722 void *argp1 = 0 ;
22723 int res1 = 0 ;
22724 long val2 ;
22725 int ecode2 = 0 ;
22726 PyObject *swig_obj[2] ;
22727
22728 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22730 if (!SWIG_IsOK(res1)) {
22731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22732 }
22733 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22734 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22735 if (!SWIG_IsOK(ecode2)) {
22736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22737 }
22738 arg2 = static_cast< long >(val2);
22739 if (arg1) (arg1)->m_keyCode = arg2;
22740
22741 resultobj = SWIG_Py_Void();
22742 return resultobj;
22743 fail:
22744 return NULL;
22745 }
22746
22747
22748 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22749 PyObject *resultobj = 0;
22750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22751 long result;
22752 void *argp1 = 0 ;
22753 int res1 = 0 ;
22754 PyObject *swig_obj[1] ;
22755
22756 if (!args) SWIG_fail;
22757 swig_obj[0] = args;
22758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22759 if (!SWIG_IsOK(res1)) {
22760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22761 }
22762 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22763 result = (long) ((arg1)->m_keyCode);
22764 resultobj = SWIG_From_long(static_cast< long >(result));
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22772 PyObject *resultobj = 0;
22773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22774 bool arg2 ;
22775 void *argp1 = 0 ;
22776 int res1 = 0 ;
22777 bool val2 ;
22778 int ecode2 = 0 ;
22779 PyObject *swig_obj[2] ;
22780
22781 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22783 if (!SWIG_IsOK(res1)) {
22784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22785 }
22786 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22787 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22788 if (!SWIG_IsOK(ecode2)) {
22789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22790 }
22791 arg2 = static_cast< bool >(val2);
22792 if (arg1) (arg1)->m_controlDown = arg2;
22793
22794 resultobj = SWIG_Py_Void();
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 PyObject *resultobj = 0;
22803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22804 bool result;
22805 void *argp1 = 0 ;
22806 int res1 = 0 ;
22807 PyObject *swig_obj[1] ;
22808
22809 if (!args) SWIG_fail;
22810 swig_obj[0] = args;
22811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22814 }
22815 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22816 result = (bool) ((arg1)->m_controlDown);
22817 {
22818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22819 }
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22827 PyObject *resultobj = 0;
22828 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22829 bool arg2 ;
22830 void *argp1 = 0 ;
22831 int res1 = 0 ;
22832 bool val2 ;
22833 int ecode2 = 0 ;
22834 PyObject *swig_obj[2] ;
22835
22836 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22842 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22843 if (!SWIG_IsOK(ecode2)) {
22844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22845 }
22846 arg2 = static_cast< bool >(val2);
22847 if (arg1) (arg1)->m_shiftDown = arg2;
22848
22849 resultobj = SWIG_Py_Void();
22850 return resultobj;
22851 fail:
22852 return NULL;
22853 }
22854
22855
22856 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22857 PyObject *resultobj = 0;
22858 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22859 bool result;
22860 void *argp1 = 0 ;
22861 int res1 = 0 ;
22862 PyObject *swig_obj[1] ;
22863
22864 if (!args) SWIG_fail;
22865 swig_obj[0] = args;
22866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22867 if (!SWIG_IsOK(res1)) {
22868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22869 }
22870 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22871 result = (bool) ((arg1)->m_shiftDown);
22872 {
22873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22874 }
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22882 PyObject *resultobj = 0;
22883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22884 bool arg2 ;
22885 void *argp1 = 0 ;
22886 int res1 = 0 ;
22887 bool val2 ;
22888 int ecode2 = 0 ;
22889 PyObject *swig_obj[2] ;
22890
22891 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22893 if (!SWIG_IsOK(res1)) {
22894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22895 }
22896 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22897 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22898 if (!SWIG_IsOK(ecode2)) {
22899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22900 }
22901 arg2 = static_cast< bool >(val2);
22902 if (arg1) (arg1)->m_altDown = arg2;
22903
22904 resultobj = SWIG_Py_Void();
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22912 PyObject *resultobj = 0;
22913 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22914 bool result;
22915 void *argp1 = 0 ;
22916 int res1 = 0 ;
22917 PyObject *swig_obj[1] ;
22918
22919 if (!args) SWIG_fail;
22920 swig_obj[0] = args;
22921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22922 if (!SWIG_IsOK(res1)) {
22923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22924 }
22925 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22926 result = (bool) ((arg1)->m_altDown);
22927 {
22928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22929 }
22930 return resultobj;
22931 fail:
22932 return NULL;
22933 }
22934
22935
22936 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22937 PyObject *resultobj = 0;
22938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22939 bool arg2 ;
22940 void *argp1 = 0 ;
22941 int res1 = 0 ;
22942 bool val2 ;
22943 int ecode2 = 0 ;
22944 PyObject *swig_obj[2] ;
22945
22946 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22948 if (!SWIG_IsOK(res1)) {
22949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22950 }
22951 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22952 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22953 if (!SWIG_IsOK(ecode2)) {
22954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22955 }
22956 arg2 = static_cast< bool >(val2);
22957 if (arg1) (arg1)->m_metaDown = arg2;
22958
22959 resultobj = SWIG_Py_Void();
22960 return resultobj;
22961 fail:
22962 return NULL;
22963 }
22964
22965
22966 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22967 PyObject *resultobj = 0;
22968 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22969 bool result;
22970 void *argp1 = 0 ;
22971 int res1 = 0 ;
22972 PyObject *swig_obj[1] ;
22973
22974 if (!args) SWIG_fail;
22975 swig_obj[0] = args;
22976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22977 if (!SWIG_IsOK(res1)) {
22978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22979 }
22980 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22981 result = (bool) ((arg1)->m_metaDown);
22982 {
22983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22984 }
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22992 PyObject *resultobj = 0;
22993 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22994 bool arg2 ;
22995 void *argp1 = 0 ;
22996 int res1 = 0 ;
22997 bool val2 ;
22998 int ecode2 = 0 ;
22999 PyObject *swig_obj[2] ;
23000
23001 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23003 if (!SWIG_IsOK(res1)) {
23004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23005 }
23006 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23007 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23008 if (!SWIG_IsOK(ecode2)) {
23009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23010 }
23011 arg2 = static_cast< bool >(val2);
23012 if (arg1) (arg1)->m_scanCode = arg2;
23013
23014 resultobj = SWIG_Py_Void();
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23022 PyObject *resultobj = 0;
23023 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23024 bool result;
23025 void *argp1 = 0 ;
23026 int res1 = 0 ;
23027 PyObject *swig_obj[1] ;
23028
23029 if (!args) SWIG_fail;
23030 swig_obj[0] = args;
23031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23032 if (!SWIG_IsOK(res1)) {
23033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23034 }
23035 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23036 result = (bool) ((arg1)->m_scanCode);
23037 {
23038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23039 }
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23047 PyObject *resultobj = 0;
23048 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23049 unsigned int arg2 ;
23050 void *argp1 = 0 ;
23051 int res1 = 0 ;
23052 unsigned int val2 ;
23053 int ecode2 = 0 ;
23054 PyObject *swig_obj[2] ;
23055
23056 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23058 if (!SWIG_IsOK(res1)) {
23059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23060 }
23061 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23062 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23063 if (!SWIG_IsOK(ecode2)) {
23064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23065 }
23066 arg2 = static_cast< unsigned int >(val2);
23067 if (arg1) (arg1)->m_rawCode = arg2;
23068
23069 resultobj = SWIG_Py_Void();
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23077 PyObject *resultobj = 0;
23078 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23079 unsigned int result;
23080 void *argp1 = 0 ;
23081 int res1 = 0 ;
23082 PyObject *swig_obj[1] ;
23083
23084 if (!args) SWIG_fail;
23085 swig_obj[0] = args;
23086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23087 if (!SWIG_IsOK(res1)) {
23088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23089 }
23090 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23091 result = (unsigned int) ((arg1)->m_rawCode);
23092 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23093 return resultobj;
23094 fail:
23095 return NULL;
23096 }
23097
23098
23099 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23100 PyObject *resultobj = 0;
23101 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23102 unsigned int arg2 ;
23103 void *argp1 = 0 ;
23104 int res1 = 0 ;
23105 unsigned int val2 ;
23106 int ecode2 = 0 ;
23107 PyObject *swig_obj[2] ;
23108
23109 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23111 if (!SWIG_IsOK(res1)) {
23112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23113 }
23114 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23115 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23116 if (!SWIG_IsOK(ecode2)) {
23117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23118 }
23119 arg2 = static_cast< unsigned int >(val2);
23120 if (arg1) (arg1)->m_rawFlags = arg2;
23121
23122 resultobj = SWIG_Py_Void();
23123 return resultobj;
23124 fail:
23125 return NULL;
23126 }
23127
23128
23129 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23130 PyObject *resultobj = 0;
23131 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23132 unsigned int result;
23133 void *argp1 = 0 ;
23134 int res1 = 0 ;
23135 PyObject *swig_obj[1] ;
23136
23137 if (!args) SWIG_fail;
23138 swig_obj[0] = args;
23139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23140 if (!SWIG_IsOK(res1)) {
23141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23142 }
23143 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23144 result = (unsigned int) ((arg1)->m_rawFlags);
23145 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23146 return resultobj;
23147 fail:
23148 return NULL;
23149 }
23150
23151
23152 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23153 PyObject *obj;
23154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23155 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23156 return SWIG_Py_Void();
23157 }
23158
23159 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23160 return SWIG_Python_InitShadowInstance(args);
23161 }
23162
23163 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23164 PyObject *resultobj = 0;
23165 wxSize const &arg1_defvalue = wxDefaultSize ;
23166 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23167 int arg2 = (int) 0 ;
23168 wxSizeEvent *result = 0 ;
23169 wxSize temp1 ;
23170 int val2 ;
23171 int ecode2 = 0 ;
23172 PyObject * obj0 = 0 ;
23173 PyObject * obj1 = 0 ;
23174 char * kwnames[] = {
23175 (char *) "sz",(char *) "winid", NULL
23176 };
23177
23178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23179 if (obj0) {
23180 {
23181 arg1 = &temp1;
23182 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23183 }
23184 }
23185 if (obj1) {
23186 ecode2 = SWIG_AsVal_int(obj1, &val2);
23187 if (!SWIG_IsOK(ecode2)) {
23188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23189 }
23190 arg2 = static_cast< int >(val2);
23191 }
23192 {
23193 PyThreadState* __tstate = wxPyBeginAllowThreads();
23194 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23195 wxPyEndAllowThreads(__tstate);
23196 if (PyErr_Occurred()) SWIG_fail;
23197 }
23198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23199 return resultobj;
23200 fail:
23201 return NULL;
23202 }
23203
23204
23205 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23206 PyObject *resultobj = 0;
23207 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23208 wxSize result;
23209 void *argp1 = 0 ;
23210 int res1 = 0 ;
23211 PyObject *swig_obj[1] ;
23212
23213 if (!args) SWIG_fail;
23214 swig_obj[0] = args;
23215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23216 if (!SWIG_IsOK(res1)) {
23217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23218 }
23219 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23220 {
23221 PyThreadState* __tstate = wxPyBeginAllowThreads();
23222 result = ((wxSizeEvent const *)arg1)->GetSize();
23223 wxPyEndAllowThreads(__tstate);
23224 if (PyErr_Occurred()) SWIG_fail;
23225 }
23226 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23234 PyObject *resultobj = 0;
23235 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23236 wxRect result;
23237 void *argp1 = 0 ;
23238 int res1 = 0 ;
23239 PyObject *swig_obj[1] ;
23240
23241 if (!args) SWIG_fail;
23242 swig_obj[0] = args;
23243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23244 if (!SWIG_IsOK(res1)) {
23245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23246 }
23247 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23248 {
23249 PyThreadState* __tstate = wxPyBeginAllowThreads();
23250 result = ((wxSizeEvent const *)arg1)->GetRect();
23251 wxPyEndAllowThreads(__tstate);
23252 if (PyErr_Occurred()) SWIG_fail;
23253 }
23254 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23262 PyObject *resultobj = 0;
23263 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23264 wxRect arg2 ;
23265 void *argp1 = 0 ;
23266 int res1 = 0 ;
23267 void *argp2 ;
23268 int res2 = 0 ;
23269 PyObject * obj0 = 0 ;
23270 PyObject * obj1 = 0 ;
23271 char * kwnames[] = {
23272 (char *) "self",(char *) "rect", NULL
23273 };
23274
23275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23277 if (!SWIG_IsOK(res1)) {
23278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23279 }
23280 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23281 {
23282 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23283 if (!SWIG_IsOK(res2)) {
23284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23285 }
23286 if (!argp2) {
23287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23288 } else {
23289 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23290 arg2 = *temp;
23291 if (SWIG_IsNewObj(res2)) delete temp;
23292 }
23293 }
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 (arg1)->SetRect(arg2);
23297 wxPyEndAllowThreads(__tstate);
23298 if (PyErr_Occurred()) SWIG_fail;
23299 }
23300 resultobj = SWIG_Py_Void();
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23308 PyObject *resultobj = 0;
23309 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23310 wxSize arg2 ;
23311 void *argp1 = 0 ;
23312 int res1 = 0 ;
23313 void *argp2 ;
23314 int res2 = 0 ;
23315 PyObject * obj0 = 0 ;
23316 PyObject * obj1 = 0 ;
23317 char * kwnames[] = {
23318 (char *) "self",(char *) "size", NULL
23319 };
23320
23321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23323 if (!SWIG_IsOK(res1)) {
23324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23325 }
23326 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23327 {
23328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23329 if (!SWIG_IsOK(res2)) {
23330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23331 }
23332 if (!argp2) {
23333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23334 } else {
23335 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23336 arg2 = *temp;
23337 if (SWIG_IsNewObj(res2)) delete temp;
23338 }
23339 }
23340 {
23341 PyThreadState* __tstate = wxPyBeginAllowThreads();
23342 wxSizeEvent_SetSize(arg1,arg2);
23343 wxPyEndAllowThreads(__tstate);
23344 if (PyErr_Occurred()) SWIG_fail;
23345 }
23346 resultobj = SWIG_Py_Void();
23347 return resultobj;
23348 fail:
23349 return NULL;
23350 }
23351
23352
23353 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23354 PyObject *resultobj = 0;
23355 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23356 wxSize *arg2 = (wxSize *) 0 ;
23357 void *argp1 = 0 ;
23358 int res1 = 0 ;
23359 void *argp2 = 0 ;
23360 int res2 = 0 ;
23361 PyObject *swig_obj[2] ;
23362
23363 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23365 if (!SWIG_IsOK(res1)) {
23366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23367 }
23368 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23369 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23370 if (!SWIG_IsOK(res2)) {
23371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23372 }
23373 arg2 = reinterpret_cast< wxSize * >(argp2);
23374 if (arg1) (arg1)->m_size = *arg2;
23375
23376 resultobj = SWIG_Py_Void();
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23384 PyObject *resultobj = 0;
23385 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23386 wxSize *result = 0 ;
23387 void *argp1 = 0 ;
23388 int res1 = 0 ;
23389 PyObject *swig_obj[1] ;
23390
23391 if (!args) SWIG_fail;
23392 swig_obj[0] = args;
23393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23394 if (!SWIG_IsOK(res1)) {
23395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23396 }
23397 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23398 result = (wxSize *)& ((arg1)->m_size);
23399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23407 PyObject *resultobj = 0;
23408 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23409 wxRect *arg2 = (wxRect *) 0 ;
23410 void *argp1 = 0 ;
23411 int res1 = 0 ;
23412 void *argp2 = 0 ;
23413 int res2 = 0 ;
23414 PyObject *swig_obj[2] ;
23415
23416 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23418 if (!SWIG_IsOK(res1)) {
23419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23420 }
23421 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23422 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23423 if (!SWIG_IsOK(res2)) {
23424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23425 }
23426 arg2 = reinterpret_cast< wxRect * >(argp2);
23427 if (arg1) (arg1)->m_rect = *arg2;
23428
23429 resultobj = SWIG_Py_Void();
23430 return resultobj;
23431 fail:
23432 return NULL;
23433 }
23434
23435
23436 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23437 PyObject *resultobj = 0;
23438 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23439 wxRect *result = 0 ;
23440 void *argp1 = 0 ;
23441 int res1 = 0 ;
23442 PyObject *swig_obj[1] ;
23443
23444 if (!args) SWIG_fail;
23445 swig_obj[0] = args;
23446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23447 if (!SWIG_IsOK(res1)) {
23448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23449 }
23450 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23451 result = (wxRect *)& ((arg1)->m_rect);
23452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23453 return resultobj;
23454 fail:
23455 return NULL;
23456 }
23457
23458
23459 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23460 PyObject *obj;
23461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23462 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23463 return SWIG_Py_Void();
23464 }
23465
23466 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23467 return SWIG_Python_InitShadowInstance(args);
23468 }
23469
23470 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23471 PyObject *resultobj = 0;
23472 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23473 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23474 int arg2 = (int) 0 ;
23475 wxMoveEvent *result = 0 ;
23476 wxPoint temp1 ;
23477 int val2 ;
23478 int ecode2 = 0 ;
23479 PyObject * obj0 = 0 ;
23480 PyObject * obj1 = 0 ;
23481 char * kwnames[] = {
23482 (char *) "pos",(char *) "winid", NULL
23483 };
23484
23485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23486 if (obj0) {
23487 {
23488 arg1 = &temp1;
23489 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23490 }
23491 }
23492 if (obj1) {
23493 ecode2 = SWIG_AsVal_int(obj1, &val2);
23494 if (!SWIG_IsOK(ecode2)) {
23495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23496 }
23497 arg2 = static_cast< int >(val2);
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23502 wxPyEndAllowThreads(__tstate);
23503 if (PyErr_Occurred()) SWIG_fail;
23504 }
23505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23513 PyObject *resultobj = 0;
23514 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23515 wxPoint result;
23516 void *argp1 = 0 ;
23517 int res1 = 0 ;
23518 PyObject *swig_obj[1] ;
23519
23520 if (!args) SWIG_fail;
23521 swig_obj[0] = args;
23522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23523 if (!SWIG_IsOK(res1)) {
23524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23525 }
23526 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23527 {
23528 PyThreadState* __tstate = wxPyBeginAllowThreads();
23529 result = ((wxMoveEvent const *)arg1)->GetPosition();
23530 wxPyEndAllowThreads(__tstate);
23531 if (PyErr_Occurred()) SWIG_fail;
23532 }
23533 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23534 return resultobj;
23535 fail:
23536 return NULL;
23537 }
23538
23539
23540 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23541 PyObject *resultobj = 0;
23542 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23543 wxRect result;
23544 void *argp1 = 0 ;
23545 int res1 = 0 ;
23546 PyObject *swig_obj[1] ;
23547
23548 if (!args) SWIG_fail;
23549 swig_obj[0] = args;
23550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23551 if (!SWIG_IsOK(res1)) {
23552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23553 }
23554 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23555 {
23556 PyThreadState* __tstate = wxPyBeginAllowThreads();
23557 result = ((wxMoveEvent const *)arg1)->GetRect();
23558 wxPyEndAllowThreads(__tstate);
23559 if (PyErr_Occurred()) SWIG_fail;
23560 }
23561 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23562 return resultobj;
23563 fail:
23564 return NULL;
23565 }
23566
23567
23568 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23569 PyObject *resultobj = 0;
23570 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23571 wxRect *arg2 = 0 ;
23572 void *argp1 = 0 ;
23573 int res1 = 0 ;
23574 wxRect temp2 ;
23575 PyObject * obj0 = 0 ;
23576 PyObject * obj1 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "self",(char *) "rect", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23583 if (!SWIG_IsOK(res1)) {
23584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23585 }
23586 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23587 {
23588 arg2 = &temp2;
23589 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23590 }
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 (arg1)->SetRect((wxRect const &)*arg2);
23594 wxPyEndAllowThreads(__tstate);
23595 if (PyErr_Occurred()) SWIG_fail;
23596 }
23597 resultobj = SWIG_Py_Void();
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23605 PyObject *resultobj = 0;
23606 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23607 wxPoint *arg2 = 0 ;
23608 void *argp1 = 0 ;
23609 int res1 = 0 ;
23610 wxPoint temp2 ;
23611 PyObject * obj0 = 0 ;
23612 PyObject * obj1 = 0 ;
23613 char * kwnames[] = {
23614 (char *) "self",(char *) "pos", NULL
23615 };
23616
23617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23619 if (!SWIG_IsOK(res1)) {
23620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23621 }
23622 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23623 {
23624 arg2 = &temp2;
23625 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23626 }
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 (arg1)->SetPosition((wxPoint const &)*arg2);
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 resultobj = SWIG_Py_Void();
23634 return resultobj;
23635 fail:
23636 return NULL;
23637 }
23638
23639
23640 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23641 PyObject *obj;
23642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23643 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23644 return SWIG_Py_Void();
23645 }
23646
23647 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 return SWIG_Python_InitShadowInstance(args);
23649 }
23650
23651 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj = 0;
23653 int arg1 = (int) 0 ;
23654 wxPaintEvent *result = 0 ;
23655 int val1 ;
23656 int ecode1 = 0 ;
23657 PyObject * obj0 = 0 ;
23658 char * kwnames[] = {
23659 (char *) "Id", NULL
23660 };
23661
23662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23663 if (obj0) {
23664 ecode1 = SWIG_AsVal_int(obj0, &val1);
23665 if (!SWIG_IsOK(ecode1)) {
23666 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23667 }
23668 arg1 = static_cast< int >(val1);
23669 }
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23673 wxPyEndAllowThreads(__tstate);
23674 if (PyErr_Occurred()) SWIG_fail;
23675 }
23676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23677 return resultobj;
23678 fail:
23679 return NULL;
23680 }
23681
23682
23683 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23684 PyObject *obj;
23685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23686 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23687 return SWIG_Py_Void();
23688 }
23689
23690 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23691 return SWIG_Python_InitShadowInstance(args);
23692 }
23693
23694 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23695 PyObject *resultobj = 0;
23696 int arg1 = (int) 0 ;
23697 wxNcPaintEvent *result = 0 ;
23698 int val1 ;
23699 int ecode1 = 0 ;
23700 PyObject * obj0 = 0 ;
23701 char * kwnames[] = {
23702 (char *) "winid", NULL
23703 };
23704
23705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23706 if (obj0) {
23707 ecode1 = SWIG_AsVal_int(obj0, &val1);
23708 if (!SWIG_IsOK(ecode1)) {
23709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23710 }
23711 arg1 = static_cast< int >(val1);
23712 }
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23716 wxPyEndAllowThreads(__tstate);
23717 if (PyErr_Occurred()) SWIG_fail;
23718 }
23719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23720 return resultobj;
23721 fail:
23722 return NULL;
23723 }
23724
23725
23726 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23727 PyObject *obj;
23728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23729 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23730 return SWIG_Py_Void();
23731 }
23732
23733 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23734 return SWIG_Python_InitShadowInstance(args);
23735 }
23736
23737 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj = 0;
23739 int arg1 = (int) 0 ;
23740 wxDC *arg2 = (wxDC *) NULL ;
23741 wxEraseEvent *result = 0 ;
23742 int val1 ;
23743 int ecode1 = 0 ;
23744 void *argp2 = 0 ;
23745 int res2 = 0 ;
23746 PyObject * obj0 = 0 ;
23747 PyObject * obj1 = 0 ;
23748 char * kwnames[] = {
23749 (char *) "Id",(char *) "dc", NULL
23750 };
23751
23752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23753 if (obj0) {
23754 ecode1 = SWIG_AsVal_int(obj0, &val1);
23755 if (!SWIG_IsOK(ecode1)) {
23756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23757 }
23758 arg1 = static_cast< int >(val1);
23759 }
23760 if (obj1) {
23761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23762 if (!SWIG_IsOK(res2)) {
23763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23764 }
23765 arg2 = reinterpret_cast< wxDC * >(argp2);
23766 }
23767 {
23768 PyThreadState* __tstate = wxPyBeginAllowThreads();
23769 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23781 PyObject *resultobj = 0;
23782 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23783 wxDC *result = 0 ;
23784 void *argp1 = 0 ;
23785 int res1 = 0 ;
23786 PyObject *swig_obj[1] ;
23787
23788 if (!args) SWIG_fail;
23789 swig_obj[0] = args;
23790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23791 if (!SWIG_IsOK(res1)) {
23792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23793 }
23794 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 {
23802 resultobj = wxPyMake_wxObject(result, (bool)0);
23803 }
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23811 PyObject *obj;
23812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23813 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23814 return SWIG_Py_Void();
23815 }
23816
23817 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23818 return SWIG_Python_InitShadowInstance(args);
23819 }
23820
23821 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj = 0;
23823 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23824 int arg2 = (int) 0 ;
23825 wxFocusEvent *result = 0 ;
23826 int val1 ;
23827 int ecode1 = 0 ;
23828 int val2 ;
23829 int ecode2 = 0 ;
23830 PyObject * obj0 = 0 ;
23831 PyObject * obj1 = 0 ;
23832 char * kwnames[] = {
23833 (char *) "type",(char *) "winid", NULL
23834 };
23835
23836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23837 if (obj0) {
23838 ecode1 = SWIG_AsVal_int(obj0, &val1);
23839 if (!SWIG_IsOK(ecode1)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23841 }
23842 arg1 = static_cast< wxEventType >(val1);
23843 }
23844 if (obj1) {
23845 ecode2 = SWIG_AsVal_int(obj1, &val2);
23846 if (!SWIG_IsOK(ecode2)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23848 }
23849 arg2 = static_cast< int >(val2);
23850 }
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23865 PyObject *resultobj = 0;
23866 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23867 wxWindow *result = 0 ;
23868 void *argp1 = 0 ;
23869 int res1 = 0 ;
23870 PyObject *swig_obj[1] ;
23871
23872 if (!args) SWIG_fail;
23873 swig_obj[0] = args;
23874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23875 if (!SWIG_IsOK(res1)) {
23876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23877 }
23878 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23882 wxPyEndAllowThreads(__tstate);
23883 if (PyErr_Occurred()) SWIG_fail;
23884 }
23885 {
23886 resultobj = wxPyMake_wxObject(result, (bool)0);
23887 }
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj = 0;
23896 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23897 wxWindow *arg2 = (wxWindow *) 0 ;
23898 void *argp1 = 0 ;
23899 int res1 = 0 ;
23900 void *argp2 = 0 ;
23901 int res2 = 0 ;
23902 PyObject * obj0 = 0 ;
23903 PyObject * obj1 = 0 ;
23904 char * kwnames[] = {
23905 (char *) "self",(char *) "win", NULL
23906 };
23907
23908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23910 if (!SWIG_IsOK(res1)) {
23911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23912 }
23913 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23914 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23915 if (!SWIG_IsOK(res2)) {
23916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23917 }
23918 arg2 = reinterpret_cast< wxWindow * >(argp2);
23919 {
23920 PyThreadState* __tstate = wxPyBeginAllowThreads();
23921 (arg1)->SetWindow(arg2);
23922 wxPyEndAllowThreads(__tstate);
23923 if (PyErr_Occurred()) SWIG_fail;
23924 }
23925 resultobj = SWIG_Py_Void();
23926 return resultobj;
23927 fail:
23928 return NULL;
23929 }
23930
23931
23932 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23933 PyObject *obj;
23934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23935 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23936 return SWIG_Py_Void();
23937 }
23938
23939 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23940 return SWIG_Python_InitShadowInstance(args);
23941 }
23942
23943 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23944 PyObject *resultobj = 0;
23945 wxWindow *arg1 = (wxWindow *) NULL ;
23946 wxChildFocusEvent *result = 0 ;
23947 void *argp1 = 0 ;
23948 int res1 = 0 ;
23949 PyObject * obj0 = 0 ;
23950 char * kwnames[] = {
23951 (char *) "win", NULL
23952 };
23953
23954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23955 if (obj0) {
23956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23957 if (!SWIG_IsOK(res1)) {
23958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23959 }
23960 arg1 = reinterpret_cast< wxWindow * >(argp1);
23961 }
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23976 PyObject *resultobj = 0;
23977 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23978 wxWindow *result = 0 ;
23979 void *argp1 = 0 ;
23980 int res1 = 0 ;
23981 PyObject *swig_obj[1] ;
23982
23983 if (!args) SWIG_fail;
23984 swig_obj[0] = args;
23985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23986 if (!SWIG_IsOK(res1)) {
23987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23988 }
23989 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 {
23997 resultobj = wxPyMake_wxObject(result, (bool)0);
23998 }
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *obj;
24007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24008 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24009 return SWIG_Py_Void();
24010 }
24011
24012 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24013 return SWIG_Python_InitShadowInstance(args);
24014 }
24015
24016 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj = 0;
24018 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24019 bool arg2 = (bool) true ;
24020 int arg3 = (int) 0 ;
24021 wxActivateEvent *result = 0 ;
24022 int val1 ;
24023 int ecode1 = 0 ;
24024 bool val2 ;
24025 int ecode2 = 0 ;
24026 int val3 ;
24027 int ecode3 = 0 ;
24028 PyObject * obj0 = 0 ;
24029 PyObject * obj1 = 0 ;
24030 PyObject * obj2 = 0 ;
24031 char * kwnames[] = {
24032 (char *) "type",(char *) "active",(char *) "Id", NULL
24033 };
24034
24035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24036 if (obj0) {
24037 ecode1 = SWIG_AsVal_int(obj0, &val1);
24038 if (!SWIG_IsOK(ecode1)) {
24039 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24040 }
24041 arg1 = static_cast< wxEventType >(val1);
24042 }
24043 if (obj1) {
24044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24045 if (!SWIG_IsOK(ecode2)) {
24046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24047 }
24048 arg2 = static_cast< bool >(val2);
24049 }
24050 if (obj2) {
24051 ecode3 = SWIG_AsVal_int(obj2, &val3);
24052 if (!SWIG_IsOK(ecode3)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24054 }
24055 arg3 = static_cast< int >(val3);
24056 }
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24060 wxPyEndAllowThreads(__tstate);
24061 if (PyErr_Occurred()) SWIG_fail;
24062 }
24063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24064 return resultobj;
24065 fail:
24066 return NULL;
24067 }
24068
24069
24070 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24071 PyObject *resultobj = 0;
24072 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24073 bool result;
24074 void *argp1 = 0 ;
24075 int res1 = 0 ;
24076 PyObject *swig_obj[1] ;
24077
24078 if (!args) SWIG_fail;
24079 swig_obj[0] = args;
24080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24081 if (!SWIG_IsOK(res1)) {
24082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24083 }
24084 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24085 {
24086 PyThreadState* __tstate = wxPyBeginAllowThreads();
24087 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24088 wxPyEndAllowThreads(__tstate);
24089 if (PyErr_Occurred()) SWIG_fail;
24090 }
24091 {
24092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24093 }
24094 return resultobj;
24095 fail:
24096 return NULL;
24097 }
24098
24099
24100 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24101 PyObject *obj;
24102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24103 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24104 return SWIG_Py_Void();
24105 }
24106
24107 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24108 return SWIG_Python_InitShadowInstance(args);
24109 }
24110
24111 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24112 PyObject *resultobj = 0;
24113 int arg1 = (int) 0 ;
24114 wxInitDialogEvent *result = 0 ;
24115 int val1 ;
24116 int ecode1 = 0 ;
24117 PyObject * obj0 = 0 ;
24118 char * kwnames[] = {
24119 (char *) "Id", NULL
24120 };
24121
24122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24123 if (obj0) {
24124 ecode1 = SWIG_AsVal_int(obj0, &val1);
24125 if (!SWIG_IsOK(ecode1)) {
24126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24127 }
24128 arg1 = static_cast< int >(val1);
24129 }
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24133 wxPyEndAllowThreads(__tstate);
24134 if (PyErr_Occurred()) SWIG_fail;
24135 }
24136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *obj;
24145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24146 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24147 return SWIG_Py_Void();
24148 }
24149
24150 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24151 return SWIG_Python_InitShadowInstance(args);
24152 }
24153
24154 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24155 PyObject *resultobj = 0;
24156 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24157 int arg2 = (int) 0 ;
24158 wxMenu *arg3 = (wxMenu *) NULL ;
24159 wxMenuEvent *result = 0 ;
24160 int val1 ;
24161 int ecode1 = 0 ;
24162 int val2 ;
24163 int ecode2 = 0 ;
24164 void *argp3 = 0 ;
24165 int res3 = 0 ;
24166 PyObject * obj0 = 0 ;
24167 PyObject * obj1 = 0 ;
24168 PyObject * obj2 = 0 ;
24169 char * kwnames[] = {
24170 (char *) "type",(char *) "winid",(char *) "menu", NULL
24171 };
24172
24173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24174 if (obj0) {
24175 ecode1 = SWIG_AsVal_int(obj0, &val1);
24176 if (!SWIG_IsOK(ecode1)) {
24177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24178 }
24179 arg1 = static_cast< wxEventType >(val1);
24180 }
24181 if (obj1) {
24182 ecode2 = SWIG_AsVal_int(obj1, &val2);
24183 if (!SWIG_IsOK(ecode2)) {
24184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24185 }
24186 arg2 = static_cast< int >(val2);
24187 }
24188 if (obj2) {
24189 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24190 if (!SWIG_IsOK(res3)) {
24191 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24192 }
24193 arg3 = reinterpret_cast< wxMenu * >(argp3);
24194 }
24195 {
24196 PyThreadState* __tstate = wxPyBeginAllowThreads();
24197 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24198 wxPyEndAllowThreads(__tstate);
24199 if (PyErr_Occurred()) SWIG_fail;
24200 }
24201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24209 PyObject *resultobj = 0;
24210 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24211 int result;
24212 void *argp1 = 0 ;
24213 int res1 = 0 ;
24214 PyObject *swig_obj[1] ;
24215
24216 if (!args) SWIG_fail;
24217 swig_obj[0] = args;
24218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24219 if (!SWIG_IsOK(res1)) {
24220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24221 }
24222 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24223 {
24224 PyThreadState* __tstate = wxPyBeginAllowThreads();
24225 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24226 wxPyEndAllowThreads(__tstate);
24227 if (PyErr_Occurred()) SWIG_fail;
24228 }
24229 resultobj = SWIG_From_int(static_cast< int >(result));
24230 return resultobj;
24231 fail:
24232 return NULL;
24233 }
24234
24235
24236 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24237 PyObject *resultobj = 0;
24238 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24239 bool result;
24240 void *argp1 = 0 ;
24241 int res1 = 0 ;
24242 PyObject *swig_obj[1] ;
24243
24244 if (!args) SWIG_fail;
24245 swig_obj[0] = args;
24246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24247 if (!SWIG_IsOK(res1)) {
24248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24249 }
24250 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 {
24258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24259 }
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24267 PyObject *resultobj = 0;
24268 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24269 wxMenu *result = 0 ;
24270 void *argp1 = 0 ;
24271 int res1 = 0 ;
24272 PyObject *swig_obj[1] ;
24273
24274 if (!args) SWIG_fail;
24275 swig_obj[0] = args;
24276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24277 if (!SWIG_IsOK(res1)) {
24278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24279 }
24280 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 {
24288 resultobj = wxPyMake_wxObject(result, (bool)0);
24289 }
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24297 PyObject *obj;
24298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24299 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24300 return SWIG_Py_Void();
24301 }
24302
24303 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24304 return SWIG_Python_InitShadowInstance(args);
24305 }
24306
24307 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24308 PyObject *resultobj = 0;
24309 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24310 int arg2 = (int) 0 ;
24311 wxCloseEvent *result = 0 ;
24312 int val1 ;
24313 int ecode1 = 0 ;
24314 int val2 ;
24315 int ecode2 = 0 ;
24316 PyObject * obj0 = 0 ;
24317 PyObject * obj1 = 0 ;
24318 char * kwnames[] = {
24319 (char *) "type",(char *) "winid", NULL
24320 };
24321
24322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24323 if (obj0) {
24324 ecode1 = SWIG_AsVal_int(obj0, &val1);
24325 if (!SWIG_IsOK(ecode1)) {
24326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24327 }
24328 arg1 = static_cast< wxEventType >(val1);
24329 }
24330 if (obj1) {
24331 ecode2 = SWIG_AsVal_int(obj1, &val2);
24332 if (!SWIG_IsOK(ecode2)) {
24333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24334 }
24335 arg2 = static_cast< int >(val2);
24336 }
24337 {
24338 PyThreadState* __tstate = wxPyBeginAllowThreads();
24339 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24353 bool arg2 ;
24354 void *argp1 = 0 ;
24355 int res1 = 0 ;
24356 bool val2 ;
24357 int ecode2 = 0 ;
24358 PyObject * obj0 = 0 ;
24359 PyObject * obj1 = 0 ;
24360 char * kwnames[] = {
24361 (char *) "self",(char *) "logOff", NULL
24362 };
24363
24364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24366 if (!SWIG_IsOK(res1)) {
24367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24368 }
24369 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24370 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24371 if (!SWIG_IsOK(ecode2)) {
24372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24373 }
24374 arg2 = static_cast< bool >(val2);
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 (arg1)->SetLoggingOff(arg2);
24378 wxPyEndAllowThreads(__tstate);
24379 if (PyErr_Occurred()) SWIG_fail;
24380 }
24381 resultobj = SWIG_Py_Void();
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24389 PyObject *resultobj = 0;
24390 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24391 bool result;
24392 void *argp1 = 0 ;
24393 int res1 = 0 ;
24394 PyObject *swig_obj[1] ;
24395
24396 if (!args) SWIG_fail;
24397 swig_obj[0] = args;
24398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24399 if (!SWIG_IsOK(res1)) {
24400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24401 }
24402 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24403 {
24404 PyThreadState* __tstate = wxPyBeginAllowThreads();
24405 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24406 wxPyEndAllowThreads(__tstate);
24407 if (PyErr_Occurred()) SWIG_fail;
24408 }
24409 {
24410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24411 }
24412 return resultobj;
24413 fail:
24414 return NULL;
24415 }
24416
24417
24418 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24419 PyObject *resultobj = 0;
24420 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24421 bool arg2 = (bool) true ;
24422 void *argp1 = 0 ;
24423 int res1 = 0 ;
24424 bool val2 ;
24425 int ecode2 = 0 ;
24426 PyObject * obj0 = 0 ;
24427 PyObject * obj1 = 0 ;
24428 char * kwnames[] = {
24429 (char *) "self",(char *) "veto", NULL
24430 };
24431
24432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24434 if (!SWIG_IsOK(res1)) {
24435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24436 }
24437 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24438 if (obj1) {
24439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24440 if (!SWIG_IsOK(ecode2)) {
24441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24442 }
24443 arg2 = static_cast< bool >(val2);
24444 }
24445 {
24446 PyThreadState* __tstate = wxPyBeginAllowThreads();
24447 (arg1)->Veto(arg2);
24448 wxPyEndAllowThreads(__tstate);
24449 if (PyErr_Occurred()) SWIG_fail;
24450 }
24451 resultobj = SWIG_Py_Void();
24452 return resultobj;
24453 fail:
24454 return NULL;
24455 }
24456
24457
24458 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24459 PyObject *resultobj = 0;
24460 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24461 bool result;
24462 void *argp1 = 0 ;
24463 int res1 = 0 ;
24464 PyObject *swig_obj[1] ;
24465
24466 if (!args) SWIG_fail;
24467 swig_obj[0] = args;
24468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24469 if (!SWIG_IsOK(res1)) {
24470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24471 }
24472 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 {
24480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24481 }
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24489 PyObject *resultobj = 0;
24490 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24491 bool arg2 ;
24492 void *argp1 = 0 ;
24493 int res1 = 0 ;
24494 bool val2 ;
24495 int ecode2 = 0 ;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 char * kwnames[] = {
24499 (char *) "self",(char *) "canVeto", NULL
24500 };
24501
24502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24504 if (!SWIG_IsOK(res1)) {
24505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24506 }
24507 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24509 if (!SWIG_IsOK(ecode2)) {
24510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24511 }
24512 arg2 = static_cast< bool >(val2);
24513 {
24514 PyThreadState* __tstate = wxPyBeginAllowThreads();
24515 (arg1)->SetCanVeto(arg2);
24516 wxPyEndAllowThreads(__tstate);
24517 if (PyErr_Occurred()) SWIG_fail;
24518 }
24519 resultobj = SWIG_Py_Void();
24520 return resultobj;
24521 fail:
24522 return NULL;
24523 }
24524
24525
24526 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24527 PyObject *resultobj = 0;
24528 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24529 bool result;
24530 void *argp1 = 0 ;
24531 int res1 = 0 ;
24532 PyObject *swig_obj[1] ;
24533
24534 if (!args) SWIG_fail;
24535 swig_obj[0] = args;
24536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24537 if (!SWIG_IsOK(res1)) {
24538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24539 }
24540 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24541 {
24542 PyThreadState* __tstate = wxPyBeginAllowThreads();
24543 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24544 wxPyEndAllowThreads(__tstate);
24545 if (PyErr_Occurred()) SWIG_fail;
24546 }
24547 {
24548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24549 }
24550 return resultobj;
24551 fail:
24552 return NULL;
24553 }
24554
24555
24556 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24557 PyObject *obj;
24558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24559 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24560 return SWIG_Py_Void();
24561 }
24562
24563 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24564 return SWIG_Python_InitShadowInstance(args);
24565 }
24566
24567 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24568 PyObject *resultobj = 0;
24569 int arg1 = (int) 0 ;
24570 bool arg2 = (bool) false ;
24571 wxShowEvent *result = 0 ;
24572 int val1 ;
24573 int ecode1 = 0 ;
24574 bool val2 ;
24575 int ecode2 = 0 ;
24576 PyObject * obj0 = 0 ;
24577 PyObject * obj1 = 0 ;
24578 char * kwnames[] = {
24579 (char *) "winid",(char *) "show", NULL
24580 };
24581
24582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24583 if (obj0) {
24584 ecode1 = SWIG_AsVal_int(obj0, &val1);
24585 if (!SWIG_IsOK(ecode1)) {
24586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24587 }
24588 arg1 = static_cast< int >(val1);
24589 }
24590 if (obj1) {
24591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24592 if (!SWIG_IsOK(ecode2)) {
24593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24594 }
24595 arg2 = static_cast< bool >(val2);
24596 }
24597 {
24598 PyThreadState* __tstate = wxPyBeginAllowThreads();
24599 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj = 0;
24612 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24613 bool arg2 ;
24614 void *argp1 = 0 ;
24615 int res1 = 0 ;
24616 bool val2 ;
24617 int ecode2 = 0 ;
24618 PyObject * obj0 = 0 ;
24619 PyObject * obj1 = 0 ;
24620 char * kwnames[] = {
24621 (char *) "self",(char *) "show", NULL
24622 };
24623
24624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24626 if (!SWIG_IsOK(res1)) {
24627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24628 }
24629 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24631 if (!SWIG_IsOK(ecode2)) {
24632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24633 }
24634 arg2 = static_cast< bool >(val2);
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 (arg1)->SetShow(arg2);
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 resultobj = SWIG_Py_Void();
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24649 PyObject *resultobj = 0;
24650 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24651 bool result;
24652 void *argp1 = 0 ;
24653 int res1 = 0 ;
24654 PyObject *swig_obj[1] ;
24655
24656 if (!args) SWIG_fail;
24657 swig_obj[0] = args;
24658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24659 if (!SWIG_IsOK(res1)) {
24660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24661 }
24662 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24663 {
24664 PyThreadState* __tstate = wxPyBeginAllowThreads();
24665 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24666 wxPyEndAllowThreads(__tstate);
24667 if (PyErr_Occurred()) SWIG_fail;
24668 }
24669 {
24670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24671 }
24672 return resultobj;
24673 fail:
24674 return NULL;
24675 }
24676
24677
24678 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24679 PyObject *obj;
24680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24681 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24682 return SWIG_Py_Void();
24683 }
24684
24685 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24686 return SWIG_Python_InitShadowInstance(args);
24687 }
24688
24689 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24690 PyObject *resultobj = 0;
24691 int arg1 = (int) 0 ;
24692 bool arg2 = (bool) true ;
24693 wxIconizeEvent *result = 0 ;
24694 int val1 ;
24695 int ecode1 = 0 ;
24696 bool val2 ;
24697 int ecode2 = 0 ;
24698 PyObject * obj0 = 0 ;
24699 PyObject * obj1 = 0 ;
24700 char * kwnames[] = {
24701 (char *) "id",(char *) "iconized", NULL
24702 };
24703
24704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24705 if (obj0) {
24706 ecode1 = SWIG_AsVal_int(obj0, &val1);
24707 if (!SWIG_IsOK(ecode1)) {
24708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24709 }
24710 arg1 = static_cast< int >(val1);
24711 }
24712 if (obj1) {
24713 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24714 if (!SWIG_IsOK(ecode2)) {
24715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24716 }
24717 arg2 = static_cast< bool >(val2);
24718 }
24719 {
24720 PyThreadState* __tstate = wxPyBeginAllowThreads();
24721 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24722 wxPyEndAllowThreads(__tstate);
24723 if (PyErr_Occurred()) SWIG_fail;
24724 }
24725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24733 PyObject *resultobj = 0;
24734 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24735 bool result;
24736 void *argp1 = 0 ;
24737 int res1 = 0 ;
24738 PyObject *swig_obj[1] ;
24739
24740 if (!args) SWIG_fail;
24741 swig_obj[0] = args;
24742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24743 if (!SWIG_IsOK(res1)) {
24744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24745 }
24746 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24747 {
24748 PyThreadState* __tstate = wxPyBeginAllowThreads();
24749 result = (bool)(arg1)->Iconized();
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 {
24754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24755 }
24756 return resultobj;
24757 fail:
24758 return NULL;
24759 }
24760
24761
24762 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24763 PyObject *obj;
24764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24765 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24766 return SWIG_Py_Void();
24767 }
24768
24769 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24770 return SWIG_Python_InitShadowInstance(args);
24771 }
24772
24773 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24774 PyObject *resultobj = 0;
24775 int arg1 = (int) 0 ;
24776 wxMaximizeEvent *result = 0 ;
24777 int val1 ;
24778 int ecode1 = 0 ;
24779 PyObject * obj0 = 0 ;
24780 char * kwnames[] = {
24781 (char *) "id", NULL
24782 };
24783
24784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24785 if (obj0) {
24786 ecode1 = SWIG_AsVal_int(obj0, &val1);
24787 if (!SWIG_IsOK(ecode1)) {
24788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24789 }
24790 arg1 = static_cast< int >(val1);
24791 }
24792 {
24793 PyThreadState* __tstate = wxPyBeginAllowThreads();
24794 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24806 PyObject *obj;
24807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24808 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24809 return SWIG_Py_Void();
24810 }
24811
24812 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24813 return SWIG_Python_InitShadowInstance(args);
24814 }
24815
24816 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24817 PyObject *resultobj = 0;
24818 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24819 wxPoint result;
24820 void *argp1 = 0 ;
24821 int res1 = 0 ;
24822 PyObject *swig_obj[1] ;
24823
24824 if (!args) SWIG_fail;
24825 swig_obj[0] = args;
24826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24829 }
24830 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 result = (arg1)->GetPosition();
24834 wxPyEndAllowThreads(__tstate);
24835 if (PyErr_Occurred()) SWIG_fail;
24836 }
24837 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24838 return resultobj;
24839 fail:
24840 return NULL;
24841 }
24842
24843
24844 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24845 PyObject *resultobj = 0;
24846 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24847 int result;
24848 void *argp1 = 0 ;
24849 int res1 = 0 ;
24850 PyObject *swig_obj[1] ;
24851
24852 if (!args) SWIG_fail;
24853 swig_obj[0] = args;
24854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24855 if (!SWIG_IsOK(res1)) {
24856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24857 }
24858 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24859 {
24860 PyThreadState* __tstate = wxPyBeginAllowThreads();
24861 result = (int)(arg1)->GetNumberOfFiles();
24862 wxPyEndAllowThreads(__tstate);
24863 if (PyErr_Occurred()) SWIG_fail;
24864 }
24865 resultobj = SWIG_From_int(static_cast< int >(result));
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24875 PyObject *result = 0 ;
24876 void *argp1 = 0 ;
24877 int res1 = 0 ;
24878 PyObject *swig_obj[1] ;
24879
24880 if (!args) SWIG_fail;
24881 swig_obj[0] = args;
24882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24883 if (!SWIG_IsOK(res1)) {
24884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24885 }
24886 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 resultobj = result;
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24901 PyObject *obj;
24902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24903 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24904 return SWIG_Py_Void();
24905 }
24906
24907 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24908 PyObject *resultobj = 0;
24909 int arg1 = (int) 0 ;
24910 wxUpdateUIEvent *result = 0 ;
24911 int val1 ;
24912 int ecode1 = 0 ;
24913 PyObject * obj0 = 0 ;
24914 char * kwnames[] = {
24915 (char *) "commandId", NULL
24916 };
24917
24918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24919 if (obj0) {
24920 ecode1 = SWIG_AsVal_int(obj0, &val1);
24921 if (!SWIG_IsOK(ecode1)) {
24922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24923 }
24924 arg1 = static_cast< int >(val1);
24925 }
24926 {
24927 PyThreadState* __tstate = wxPyBeginAllowThreads();
24928 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24929 wxPyEndAllowThreads(__tstate);
24930 if (PyErr_Occurred()) SWIG_fail;
24931 }
24932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24940 PyObject *resultobj = 0;
24941 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24942 bool result;
24943 void *argp1 = 0 ;
24944 int res1 = 0 ;
24945 PyObject *swig_obj[1] ;
24946
24947 if (!args) SWIG_fail;
24948 swig_obj[0] = args;
24949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24950 if (!SWIG_IsOK(res1)) {
24951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24952 }
24953 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 {
24961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24970 PyObject *resultobj = 0;
24971 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24972 bool result;
24973 void *argp1 = 0 ;
24974 int res1 = 0 ;
24975 PyObject *swig_obj[1] ;
24976
24977 if (!args) SWIG_fail;
24978 swig_obj[0] = args;
24979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24980 if (!SWIG_IsOK(res1)) {
24981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24982 }
24983 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 {
24991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24992 }
24993 return resultobj;
24994 fail:
24995 return NULL;
24996 }
24997
24998
24999 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25000 PyObject *resultobj = 0;
25001 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25002 bool result;
25003 void *argp1 = 0 ;
25004 int res1 = 0 ;
25005 PyObject *swig_obj[1] ;
25006
25007 if (!args) SWIG_fail;
25008 swig_obj[0] = args;
25009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25010 if (!SWIG_IsOK(res1)) {
25011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25012 }
25013 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25030 PyObject *resultobj = 0;
25031 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25032 wxString result;
25033 void *argp1 = 0 ;
25034 int res1 = 0 ;
25035 PyObject *swig_obj[1] ;
25036
25037 if (!args) SWIG_fail;
25038 swig_obj[0] = args;
25039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25040 if (!SWIG_IsOK(res1)) {
25041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25042 }
25043 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 {
25051 #if wxUSE_UNICODE
25052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25053 #else
25054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25055 #endif
25056 }
25057 return resultobj;
25058 fail:
25059 return NULL;
25060 }
25061
25062
25063 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25064 PyObject *resultobj = 0;
25065 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25066 bool result;
25067 void *argp1 = 0 ;
25068 int res1 = 0 ;
25069 PyObject *swig_obj[1] ;
25070
25071 if (!args) SWIG_fail;
25072 swig_obj[0] = args;
25073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25074 if (!SWIG_IsOK(res1)) {
25075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25076 }
25077 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25078 {
25079 PyThreadState* __tstate = wxPyBeginAllowThreads();
25080 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 {
25085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25086 }
25087 return resultobj;
25088 fail:
25089 return NULL;
25090 }
25091
25092
25093 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25094 PyObject *resultobj = 0;
25095 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25096 bool result;
25097 void *argp1 = 0 ;
25098 int res1 = 0 ;
25099 PyObject *swig_obj[1] ;
25100
25101 if (!args) SWIG_fail;
25102 swig_obj[0] = args;
25103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25104 if (!SWIG_IsOK(res1)) {
25105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25106 }
25107 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 {
25115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25116 }
25117 return resultobj;
25118 fail:
25119 return NULL;
25120 }
25121
25122
25123 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25124 PyObject *resultobj = 0;
25125 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25126 bool result;
25127 void *argp1 = 0 ;
25128 int res1 = 0 ;
25129 PyObject *swig_obj[1] ;
25130
25131 if (!args) SWIG_fail;
25132 swig_obj[0] = args;
25133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25134 if (!SWIG_IsOK(res1)) {
25135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25136 }
25137 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 {
25145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25146 }
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25154 PyObject *resultobj = 0;
25155 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25156 bool result;
25157 void *argp1 = 0 ;
25158 int res1 = 0 ;
25159 PyObject *swig_obj[1] ;
25160
25161 if (!args) SWIG_fail;
25162 swig_obj[0] = args;
25163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25164 if (!SWIG_IsOK(res1)) {
25165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25166 }
25167 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25168 {
25169 PyThreadState* __tstate = wxPyBeginAllowThreads();
25170 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25171 wxPyEndAllowThreads(__tstate);
25172 if (PyErr_Occurred()) SWIG_fail;
25173 }
25174 {
25175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25176 }
25177 return resultobj;
25178 fail:
25179 return NULL;
25180 }
25181
25182
25183 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25184 PyObject *resultobj = 0;
25185 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25186 bool arg2 ;
25187 void *argp1 = 0 ;
25188 int res1 = 0 ;
25189 bool val2 ;
25190 int ecode2 = 0 ;
25191 PyObject * obj0 = 0 ;
25192 PyObject * obj1 = 0 ;
25193 char * kwnames[] = {
25194 (char *) "self",(char *) "check", NULL
25195 };
25196
25197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25199 if (!SWIG_IsOK(res1)) {
25200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25201 }
25202 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25203 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25204 if (!SWIG_IsOK(ecode2)) {
25205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25206 }
25207 arg2 = static_cast< bool >(val2);
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 (arg1)->Check(arg2);
25211 wxPyEndAllowThreads(__tstate);
25212 if (PyErr_Occurred()) SWIG_fail;
25213 }
25214 resultobj = SWIG_Py_Void();
25215 return resultobj;
25216 fail:
25217 return NULL;
25218 }
25219
25220
25221 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25222 PyObject *resultobj = 0;
25223 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25224 bool arg2 ;
25225 void *argp1 = 0 ;
25226 int res1 = 0 ;
25227 bool val2 ;
25228 int ecode2 = 0 ;
25229 PyObject * obj0 = 0 ;
25230 PyObject * obj1 = 0 ;
25231 char * kwnames[] = {
25232 (char *) "self",(char *) "enable", NULL
25233 };
25234
25235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25237 if (!SWIG_IsOK(res1)) {
25238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25239 }
25240 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25241 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25242 if (!SWIG_IsOK(ecode2)) {
25243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25244 }
25245 arg2 = static_cast< bool >(val2);
25246 {
25247 PyThreadState* __tstate = wxPyBeginAllowThreads();
25248 (arg1)->Enable(arg2);
25249 wxPyEndAllowThreads(__tstate);
25250 if (PyErr_Occurred()) SWIG_fail;
25251 }
25252 resultobj = SWIG_Py_Void();
25253 return resultobj;
25254 fail:
25255 return NULL;
25256 }
25257
25258
25259 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25260 PyObject *resultobj = 0;
25261 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25262 bool arg2 ;
25263 void *argp1 = 0 ;
25264 int res1 = 0 ;
25265 bool val2 ;
25266 int ecode2 = 0 ;
25267 PyObject * obj0 = 0 ;
25268 PyObject * obj1 = 0 ;
25269 char * kwnames[] = {
25270 (char *) "self",(char *) "show", NULL
25271 };
25272
25273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25275 if (!SWIG_IsOK(res1)) {
25276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25277 }
25278 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25279 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25280 if (!SWIG_IsOK(ecode2)) {
25281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25282 }
25283 arg2 = static_cast< bool >(val2);
25284 {
25285 PyThreadState* __tstate = wxPyBeginAllowThreads();
25286 (arg1)->Show(arg2);
25287 wxPyEndAllowThreads(__tstate);
25288 if (PyErr_Occurred()) SWIG_fail;
25289 }
25290 resultobj = SWIG_Py_Void();
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25298 PyObject *resultobj = 0;
25299 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25300 wxString *arg2 = 0 ;
25301 void *argp1 = 0 ;
25302 int res1 = 0 ;
25303 bool temp2 = false ;
25304 PyObject * obj0 = 0 ;
25305 PyObject * obj1 = 0 ;
25306 char * kwnames[] = {
25307 (char *) "self",(char *) "text", NULL
25308 };
25309
25310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25312 if (!SWIG_IsOK(res1)) {
25313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25314 }
25315 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25316 {
25317 arg2 = wxString_in_helper(obj1);
25318 if (arg2 == NULL) SWIG_fail;
25319 temp2 = true;
25320 }
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 (arg1)->SetText((wxString const &)*arg2);
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 resultobj = SWIG_Py_Void();
25328 {
25329 if (temp2)
25330 delete arg2;
25331 }
25332 return resultobj;
25333 fail:
25334 {
25335 if (temp2)
25336 delete arg2;
25337 }
25338 return NULL;
25339 }
25340
25341
25342 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25343 PyObject *resultobj = 0;
25344 long arg1 ;
25345 long val1 ;
25346 int ecode1 = 0 ;
25347 PyObject * obj0 = 0 ;
25348 char * kwnames[] = {
25349 (char *) "updateInterval", NULL
25350 };
25351
25352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25353 ecode1 = SWIG_AsVal_long(obj0, &val1);
25354 if (!SWIG_IsOK(ecode1)) {
25355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25356 }
25357 arg1 = static_cast< long >(val1);
25358 {
25359 PyThreadState* __tstate = wxPyBeginAllowThreads();
25360 wxUpdateUIEvent::SetUpdateInterval(arg1);
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_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25372 PyObject *resultobj = 0;
25373 long result;
25374
25375 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25376 {
25377 PyThreadState* __tstate = wxPyBeginAllowThreads();
25378 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25379 wxPyEndAllowThreads(__tstate);
25380 if (PyErr_Occurred()) SWIG_fail;
25381 }
25382 resultobj = SWIG_From_long(static_cast< long >(result));
25383 return resultobj;
25384 fail:
25385 return NULL;
25386 }
25387
25388
25389 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25390 PyObject *resultobj = 0;
25391 wxWindow *arg1 = (wxWindow *) 0 ;
25392 bool result;
25393 void *argp1 = 0 ;
25394 int res1 = 0 ;
25395 PyObject * obj0 = 0 ;
25396 char * kwnames[] = {
25397 (char *) "win", NULL
25398 };
25399
25400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25402 if (!SWIG_IsOK(res1)) {
25403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25404 }
25405 arg1 = reinterpret_cast< wxWindow * >(argp1);
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25409 wxPyEndAllowThreads(__tstate);
25410 if (PyErr_Occurred()) SWIG_fail;
25411 }
25412 {
25413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25414 }
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25422 PyObject *resultobj = 0;
25423
25424 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 wxUpdateUIEvent::ResetUpdateTime();
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 resultobj = SWIG_Py_Void();
25432 return resultobj;
25433 fail:
25434 return NULL;
25435 }
25436
25437
25438 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25439 PyObject *resultobj = 0;
25440 wxUpdateUIMode arg1 ;
25441 int val1 ;
25442 int ecode1 = 0 ;
25443 PyObject * obj0 = 0 ;
25444 char * kwnames[] = {
25445 (char *) "mode", NULL
25446 };
25447
25448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25449 ecode1 = SWIG_AsVal_int(obj0, &val1);
25450 if (!SWIG_IsOK(ecode1)) {
25451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25452 }
25453 arg1 = static_cast< wxUpdateUIMode >(val1);
25454 {
25455 PyThreadState* __tstate = wxPyBeginAllowThreads();
25456 wxUpdateUIEvent::SetMode(arg1);
25457 wxPyEndAllowThreads(__tstate);
25458 if (PyErr_Occurred()) SWIG_fail;
25459 }
25460 resultobj = SWIG_Py_Void();
25461 return resultobj;
25462 fail:
25463 return NULL;
25464 }
25465
25466
25467 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25468 PyObject *resultobj = 0;
25469 wxUpdateUIMode result;
25470
25471 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25472 {
25473 PyThreadState* __tstate = wxPyBeginAllowThreads();
25474 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25475 wxPyEndAllowThreads(__tstate);
25476 if (PyErr_Occurred()) SWIG_fail;
25477 }
25478 resultobj = SWIG_From_int(static_cast< int >(result));
25479 return resultobj;
25480 fail:
25481 return NULL;
25482 }
25483
25484
25485 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25486 PyObject *obj;
25487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25488 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25489 return SWIG_Py_Void();
25490 }
25491
25492 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25493 return SWIG_Python_InitShadowInstance(args);
25494 }
25495
25496 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25497 PyObject *resultobj = 0;
25498 wxSysColourChangedEvent *result = 0 ;
25499
25500 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25501 {
25502 PyThreadState* __tstate = wxPyBeginAllowThreads();
25503 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25504 wxPyEndAllowThreads(__tstate);
25505 if (PyErr_Occurred()) SWIG_fail;
25506 }
25507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25508 return resultobj;
25509 fail:
25510 return NULL;
25511 }
25512
25513
25514 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25515 PyObject *obj;
25516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25517 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25518 return SWIG_Py_Void();
25519 }
25520
25521 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25522 return SWIG_Python_InitShadowInstance(args);
25523 }
25524
25525 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25526 PyObject *resultobj = 0;
25527 int arg1 = (int) 0 ;
25528 wxWindow *arg2 = (wxWindow *) NULL ;
25529 wxMouseCaptureChangedEvent *result = 0 ;
25530 int val1 ;
25531 int ecode1 = 0 ;
25532 void *argp2 = 0 ;
25533 int res2 = 0 ;
25534 PyObject * obj0 = 0 ;
25535 PyObject * obj1 = 0 ;
25536 char * kwnames[] = {
25537 (char *) "winid",(char *) "gainedCapture", NULL
25538 };
25539
25540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25541 if (obj0) {
25542 ecode1 = SWIG_AsVal_int(obj0, &val1);
25543 if (!SWIG_IsOK(ecode1)) {
25544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25545 }
25546 arg1 = static_cast< int >(val1);
25547 }
25548 if (obj1) {
25549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25550 if (!SWIG_IsOK(res2)) {
25551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25552 }
25553 arg2 = reinterpret_cast< wxWindow * >(argp2);
25554 }
25555 {
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25558 wxPyEndAllowThreads(__tstate);
25559 if (PyErr_Occurred()) SWIG_fail;
25560 }
25561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25562 return resultobj;
25563 fail:
25564 return NULL;
25565 }
25566
25567
25568 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25569 PyObject *resultobj = 0;
25570 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25571 wxWindow *result = 0 ;
25572 void *argp1 = 0 ;
25573 int res1 = 0 ;
25574 PyObject *swig_obj[1] ;
25575
25576 if (!args) SWIG_fail;
25577 swig_obj[0] = args;
25578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25579 if (!SWIG_IsOK(res1)) {
25580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25581 }
25582 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25583 {
25584 PyThreadState* __tstate = wxPyBeginAllowThreads();
25585 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25586 wxPyEndAllowThreads(__tstate);
25587 if (PyErr_Occurred()) SWIG_fail;
25588 }
25589 {
25590 resultobj = wxPyMake_wxObject(result, (bool)0);
25591 }
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25599 PyObject *obj;
25600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25601 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25602 return SWIG_Py_Void();
25603 }
25604
25605 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 return SWIG_Python_InitShadowInstance(args);
25607 }
25608
25609 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 int arg1 = (int) 0 ;
25612 wxMouseCaptureLostEvent *result = 0 ;
25613 int val1 ;
25614 int ecode1 = 0 ;
25615 PyObject * obj0 = 0 ;
25616 char * kwnames[] = {
25617 (char *) "winid", NULL
25618 };
25619
25620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25621 if (obj0) {
25622 ecode1 = SWIG_AsVal_int(obj0, &val1);
25623 if (!SWIG_IsOK(ecode1)) {
25624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25625 }
25626 arg1 = static_cast< int >(val1);
25627 }
25628 {
25629 PyThreadState* __tstate = wxPyBeginAllowThreads();
25630 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25635 return resultobj;
25636 fail:
25637 return NULL;
25638 }
25639
25640
25641 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25642 PyObject *obj;
25643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25644 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25645 return SWIG_Py_Void();
25646 }
25647
25648 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25649 return SWIG_Python_InitShadowInstance(args);
25650 }
25651
25652 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25653 PyObject *resultobj = 0;
25654 wxDisplayChangedEvent *result = 0 ;
25655
25656 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25657 {
25658 PyThreadState* __tstate = wxPyBeginAllowThreads();
25659 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25660 wxPyEndAllowThreads(__tstate);
25661 if (PyErr_Occurred()) SWIG_fail;
25662 }
25663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25664 return resultobj;
25665 fail:
25666 return NULL;
25667 }
25668
25669
25670 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25671 PyObject *obj;
25672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25673 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25674 return SWIG_Py_Void();
25675 }
25676
25677 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25678 return SWIG_Python_InitShadowInstance(args);
25679 }
25680
25681 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25682 PyObject *resultobj = 0;
25683 int arg1 = (int) 0 ;
25684 wxPaletteChangedEvent *result = 0 ;
25685 int val1 ;
25686 int ecode1 = 0 ;
25687 PyObject * obj0 = 0 ;
25688 char * kwnames[] = {
25689 (char *) "id", NULL
25690 };
25691
25692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25693 if (obj0) {
25694 ecode1 = SWIG_AsVal_int(obj0, &val1);
25695 if (!SWIG_IsOK(ecode1)) {
25696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25697 }
25698 arg1 = static_cast< int >(val1);
25699 }
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25714 PyObject *resultobj = 0;
25715 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25716 wxWindow *arg2 = (wxWindow *) 0 ;
25717 void *argp1 = 0 ;
25718 int res1 = 0 ;
25719 void *argp2 = 0 ;
25720 int res2 = 0 ;
25721 PyObject * obj0 = 0 ;
25722 PyObject * obj1 = 0 ;
25723 char * kwnames[] = {
25724 (char *) "self",(char *) "win", NULL
25725 };
25726
25727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25731 }
25732 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25734 if (!SWIG_IsOK(res2)) {
25735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25736 }
25737 arg2 = reinterpret_cast< wxWindow * >(argp2);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 (arg1)->SetChangedWindow(arg2);
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 resultobj = SWIG_Py_Void();
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25752 PyObject *resultobj = 0;
25753 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25754 wxWindow *result = 0 ;
25755 void *argp1 = 0 ;
25756 int res1 = 0 ;
25757 PyObject *swig_obj[1] ;
25758
25759 if (!args) SWIG_fail;
25760 swig_obj[0] = args;
25761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25762 if (!SWIG_IsOK(res1)) {
25763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25764 }
25765 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 result = (wxWindow *)(arg1)->GetChangedWindow();
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 {
25773 resultobj = wxPyMake_wxObject(result, (bool)0);
25774 }
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25782 PyObject *obj;
25783 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25784 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25785 return SWIG_Py_Void();
25786 }
25787
25788 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25789 return SWIG_Python_InitShadowInstance(args);
25790 }
25791
25792 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj = 0;
25794 int arg1 = (int) 0 ;
25795 wxQueryNewPaletteEvent *result = 0 ;
25796 int val1 ;
25797 int ecode1 = 0 ;
25798 PyObject * obj0 = 0 ;
25799 char * kwnames[] = {
25800 (char *) "winid", NULL
25801 };
25802
25803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25804 if (obj0) {
25805 ecode1 = SWIG_AsVal_int(obj0, &val1);
25806 if (!SWIG_IsOK(ecode1)) {
25807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25808 }
25809 arg1 = static_cast< int >(val1);
25810 }
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj = 0;
25826 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25827 bool arg2 ;
25828 void *argp1 = 0 ;
25829 int res1 = 0 ;
25830 bool val2 ;
25831 int ecode2 = 0 ;
25832 PyObject * obj0 = 0 ;
25833 PyObject * obj1 = 0 ;
25834 char * kwnames[] = {
25835 (char *) "self",(char *) "realized", NULL
25836 };
25837
25838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25840 if (!SWIG_IsOK(res1)) {
25841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25842 }
25843 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25845 if (!SWIG_IsOK(ecode2)) {
25846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25847 }
25848 arg2 = static_cast< bool >(val2);
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 (arg1)->SetPaletteRealized(arg2);
25852 wxPyEndAllowThreads(__tstate);
25853 if (PyErr_Occurred()) SWIG_fail;
25854 }
25855 resultobj = SWIG_Py_Void();
25856 return resultobj;
25857 fail:
25858 return NULL;
25859 }
25860
25861
25862 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25863 PyObject *resultobj = 0;
25864 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25865 bool result;
25866 void *argp1 = 0 ;
25867 int res1 = 0 ;
25868 PyObject *swig_obj[1] ;
25869
25870 if (!args) SWIG_fail;
25871 swig_obj[0] = args;
25872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25873 if (!SWIG_IsOK(res1)) {
25874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25875 }
25876 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 {
25884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25885 }
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25893 PyObject *obj;
25894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25895 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25896 return SWIG_Py_Void();
25897 }
25898
25899 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25900 return SWIG_Python_InitShadowInstance(args);
25901 }
25902
25903 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25904 PyObject *resultobj = 0;
25905 wxNavigationKeyEvent *result = 0 ;
25906
25907 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25908 {
25909 PyThreadState* __tstate = wxPyBeginAllowThreads();
25910 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25911 wxPyEndAllowThreads(__tstate);
25912 if (PyErr_Occurred()) SWIG_fail;
25913 }
25914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25922 PyObject *resultobj = 0;
25923 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25924 bool result;
25925 void *argp1 = 0 ;
25926 int res1 = 0 ;
25927 PyObject *swig_obj[1] ;
25928
25929 if (!args) SWIG_fail;
25930 swig_obj[0] = args;
25931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25932 if (!SWIG_IsOK(res1)) {
25933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25934 }
25935 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25936 {
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25939 wxPyEndAllowThreads(__tstate);
25940 if (PyErr_Occurred()) SWIG_fail;
25941 }
25942 {
25943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25944 }
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25952 PyObject *resultobj = 0;
25953 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25954 bool arg2 ;
25955 void *argp1 = 0 ;
25956 int res1 = 0 ;
25957 bool val2 ;
25958 int ecode2 = 0 ;
25959 PyObject * obj0 = 0 ;
25960 PyObject * obj1 = 0 ;
25961 char * kwnames[] = {
25962 (char *) "self",(char *) "forward", NULL
25963 };
25964
25965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25969 }
25970 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25971 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25972 if (!SWIG_IsOK(ecode2)) {
25973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25974 }
25975 arg2 = static_cast< bool >(val2);
25976 {
25977 PyThreadState* __tstate = wxPyBeginAllowThreads();
25978 (arg1)->SetDirection(arg2);
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 resultobj = SWIG_Py_Void();
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25990 PyObject *resultobj = 0;
25991 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25992 bool result;
25993 void *argp1 = 0 ;
25994 int res1 = 0 ;
25995 PyObject *swig_obj[1] ;
25996
25997 if (!args) SWIG_fail;
25998 swig_obj[0] = args;
25999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26002 }
26003 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26004 {
26005 PyThreadState* __tstate = wxPyBeginAllowThreads();
26006 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26007 wxPyEndAllowThreads(__tstate);
26008 if (PyErr_Occurred()) SWIG_fail;
26009 }
26010 {
26011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26012 }
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj = 0;
26021 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26022 bool arg2 ;
26023 void *argp1 = 0 ;
26024 int res1 = 0 ;
26025 bool val2 ;
26026 int ecode2 = 0 ;
26027 PyObject * obj0 = 0 ;
26028 PyObject * obj1 = 0 ;
26029 char * kwnames[] = {
26030 (char *) "self",(char *) "ischange", NULL
26031 };
26032
26033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26035 if (!SWIG_IsOK(res1)) {
26036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26037 }
26038 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26039 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26040 if (!SWIG_IsOK(ecode2)) {
26041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26042 }
26043 arg2 = static_cast< bool >(val2);
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 (arg1)->SetWindowChange(arg2);
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 resultobj = SWIG_Py_Void();
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26058 PyObject *resultobj = 0;
26059 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26060 bool result;
26061 void *argp1 = 0 ;
26062 int res1 = 0 ;
26063 PyObject *swig_obj[1] ;
26064
26065 if (!args) SWIG_fail;
26066 swig_obj[0] = args;
26067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26068 if (!SWIG_IsOK(res1)) {
26069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26070 }
26071 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26072 {
26073 PyThreadState* __tstate = wxPyBeginAllowThreads();
26074 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26075 wxPyEndAllowThreads(__tstate);
26076 if (PyErr_Occurred()) SWIG_fail;
26077 }
26078 {
26079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26080 }
26081 return resultobj;
26082 fail:
26083 return NULL;
26084 }
26085
26086
26087 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26088 PyObject *resultobj = 0;
26089 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26090 bool arg2 ;
26091 void *argp1 = 0 ;
26092 int res1 = 0 ;
26093 bool val2 ;
26094 int ecode2 = 0 ;
26095 PyObject * obj0 = 0 ;
26096 PyObject * obj1 = 0 ;
26097 char * kwnames[] = {
26098 (char *) "self",(char *) "bIs", NULL
26099 };
26100
26101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26103 if (!SWIG_IsOK(res1)) {
26104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26105 }
26106 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26107 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26108 if (!SWIG_IsOK(ecode2)) {
26109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26110 }
26111 arg2 = static_cast< bool >(val2);
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 (arg1)->SetFromTab(arg2);
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_Py_Void();
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj = 0;
26127 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26128 long arg2 ;
26129 void *argp1 = 0 ;
26130 int res1 = 0 ;
26131 long val2 ;
26132 int ecode2 = 0 ;
26133 PyObject * obj0 = 0 ;
26134 PyObject * obj1 = 0 ;
26135 char * kwnames[] = {
26136 (char *) "self",(char *) "flags", NULL
26137 };
26138
26139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26143 }
26144 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26145 ecode2 = SWIG_AsVal_long(obj1, &val2);
26146 if (!SWIG_IsOK(ecode2)) {
26147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26148 }
26149 arg2 = static_cast< long >(val2);
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 (arg1)->SetFlags(arg2);
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 resultobj = SWIG_Py_Void();
26157 return resultobj;
26158 fail:
26159 return NULL;
26160 }
26161
26162
26163 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26164 PyObject *resultobj = 0;
26165 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26166 wxWindow *result = 0 ;
26167 void *argp1 = 0 ;
26168 int res1 = 0 ;
26169 PyObject *swig_obj[1] ;
26170
26171 if (!args) SWIG_fail;
26172 swig_obj[0] = args;
26173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26174 if (!SWIG_IsOK(res1)) {
26175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26176 }
26177 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 {
26185 resultobj = wxPyMake_wxObject(result, (bool)0);
26186 }
26187 return resultobj;
26188 fail:
26189 return NULL;
26190 }
26191
26192
26193 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26194 PyObject *resultobj = 0;
26195 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26196 wxWindow *arg2 = (wxWindow *) 0 ;
26197 void *argp1 = 0 ;
26198 int res1 = 0 ;
26199 void *argp2 = 0 ;
26200 int res2 = 0 ;
26201 PyObject * obj0 = 0 ;
26202 PyObject * obj1 = 0 ;
26203 char * kwnames[] = {
26204 (char *) "self",(char *) "win", NULL
26205 };
26206
26207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26209 if (!SWIG_IsOK(res1)) {
26210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26211 }
26212 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26214 if (!SWIG_IsOK(res2)) {
26215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26216 }
26217 arg2 = reinterpret_cast< wxWindow * >(argp2);
26218 {
26219 PyThreadState* __tstate = wxPyBeginAllowThreads();
26220 (arg1)->SetCurrentFocus(arg2);
26221 wxPyEndAllowThreads(__tstate);
26222 if (PyErr_Occurred()) SWIG_fail;
26223 }
26224 resultobj = SWIG_Py_Void();
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26232 PyObject *obj;
26233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26234 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26235 return SWIG_Py_Void();
26236 }
26237
26238 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26239 return SWIG_Python_InitShadowInstance(args);
26240 }
26241
26242 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj = 0;
26244 wxWindow *arg1 = (wxWindow *) NULL ;
26245 wxWindowCreateEvent *result = 0 ;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject * obj0 = 0 ;
26249 char * kwnames[] = {
26250 (char *) "win", NULL
26251 };
26252
26253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26254 if (obj0) {
26255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26256 if (!SWIG_IsOK(res1)) {
26257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26258 }
26259 arg1 = reinterpret_cast< wxWindow * >(argp1);
26260 }
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *resultobj = 0;
26276 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26277 wxWindow *result = 0 ;
26278 void *argp1 = 0 ;
26279 int res1 = 0 ;
26280 PyObject *swig_obj[1] ;
26281
26282 if (!args) SWIG_fail;
26283 swig_obj[0] = args;
26284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26285 if (!SWIG_IsOK(res1)) {
26286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26287 }
26288 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 {
26296 resultobj = wxPyMake_wxObject(result, (bool)0);
26297 }
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *obj;
26306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26307 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26308 return SWIG_Py_Void();
26309 }
26310
26311 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 return SWIG_Python_InitShadowInstance(args);
26313 }
26314
26315 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj = 0;
26317 wxWindow *arg1 = (wxWindow *) NULL ;
26318 wxWindowDestroyEvent *result = 0 ;
26319 void *argp1 = 0 ;
26320 int res1 = 0 ;
26321 PyObject * obj0 = 0 ;
26322 char * kwnames[] = {
26323 (char *) "win", NULL
26324 };
26325
26326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26327 if (obj0) {
26328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26331 }
26332 arg1 = reinterpret_cast< wxWindow * >(argp1);
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26348 PyObject *resultobj = 0;
26349 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26350 wxWindow *result = 0 ;
26351 void *argp1 = 0 ;
26352 int res1 = 0 ;
26353 PyObject *swig_obj[1] ;
26354
26355 if (!args) SWIG_fail;
26356 swig_obj[0] = args;
26357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26360 }
26361 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26362 {
26363 PyThreadState* __tstate = wxPyBeginAllowThreads();
26364 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 {
26369 resultobj = wxPyMake_wxObject(result, (bool)0);
26370 }
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 PyObject *obj;
26379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26380 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26381 return SWIG_Py_Void();
26382 }
26383
26384 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26385 return SWIG_Python_InitShadowInstance(args);
26386 }
26387
26388 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26389 PyObject *resultobj = 0;
26390 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26391 int arg2 = (int) 0 ;
26392 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26393 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26394 wxContextMenuEvent *result = 0 ;
26395 int val1 ;
26396 int ecode1 = 0 ;
26397 int val2 ;
26398 int ecode2 = 0 ;
26399 wxPoint temp3 ;
26400 PyObject * obj0 = 0 ;
26401 PyObject * obj1 = 0 ;
26402 PyObject * obj2 = 0 ;
26403 char * kwnames[] = {
26404 (char *) "type",(char *) "winid",(char *) "pt", NULL
26405 };
26406
26407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26408 if (obj0) {
26409 ecode1 = SWIG_AsVal_int(obj0, &val1);
26410 if (!SWIG_IsOK(ecode1)) {
26411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26412 }
26413 arg1 = static_cast< wxEventType >(val1);
26414 }
26415 if (obj1) {
26416 ecode2 = SWIG_AsVal_int(obj1, &val2);
26417 if (!SWIG_IsOK(ecode2)) {
26418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26419 }
26420 arg2 = static_cast< int >(val2);
26421 }
26422 if (obj2) {
26423 {
26424 arg3 = &temp3;
26425 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26426 }
26427 }
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26442 PyObject *resultobj = 0;
26443 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26444 wxPoint *result = 0 ;
26445 void *argp1 = 0 ;
26446 int res1 = 0 ;
26447 PyObject *swig_obj[1] ;
26448
26449 if (!args) SWIG_fail;
26450 swig_obj[0] = args;
26451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26452 if (!SWIG_IsOK(res1)) {
26453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26454 }
26455 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26456 {
26457 PyThreadState* __tstate = wxPyBeginAllowThreads();
26458 {
26459 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26460 result = (wxPoint *) &_result_ref;
26461 }
26462 wxPyEndAllowThreads(__tstate);
26463 if (PyErr_Occurred()) SWIG_fail;
26464 }
26465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26466 return resultobj;
26467 fail:
26468 return NULL;
26469 }
26470
26471
26472 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26473 PyObject *resultobj = 0;
26474 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26475 wxPoint *arg2 = 0 ;
26476 void *argp1 = 0 ;
26477 int res1 = 0 ;
26478 wxPoint temp2 ;
26479 PyObject * obj0 = 0 ;
26480 PyObject * obj1 = 0 ;
26481 char * kwnames[] = {
26482 (char *) "self",(char *) "pos", NULL
26483 };
26484
26485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26487 if (!SWIG_IsOK(res1)) {
26488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26489 }
26490 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26491 {
26492 arg2 = &temp2;
26493 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26494 }
26495 {
26496 PyThreadState* __tstate = wxPyBeginAllowThreads();
26497 (arg1)->SetPosition((wxPoint const &)*arg2);
26498 wxPyEndAllowThreads(__tstate);
26499 if (PyErr_Occurred()) SWIG_fail;
26500 }
26501 resultobj = SWIG_Py_Void();
26502 return resultobj;
26503 fail:
26504 return NULL;
26505 }
26506
26507
26508 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26509 PyObject *obj;
26510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26511 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26512 return SWIG_Py_Void();
26513 }
26514
26515 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 return SWIG_Python_InitShadowInstance(args);
26517 }
26518
26519 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26520 PyObject *resultobj = 0;
26521 wxIdleEvent *result = 0 ;
26522
26523 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 result = (wxIdleEvent *)new wxIdleEvent();
26527 wxPyEndAllowThreads(__tstate);
26528 if (PyErr_Occurred()) SWIG_fail;
26529 }
26530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26531 return resultobj;
26532 fail:
26533 return NULL;
26534 }
26535
26536
26537 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26538 PyObject *resultobj = 0;
26539 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26540 bool arg2 = (bool) true ;
26541 void *argp1 = 0 ;
26542 int res1 = 0 ;
26543 bool val2 ;
26544 int ecode2 = 0 ;
26545 PyObject * obj0 = 0 ;
26546 PyObject * obj1 = 0 ;
26547 char * kwnames[] = {
26548 (char *) "self",(char *) "needMore", NULL
26549 };
26550
26551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26553 if (!SWIG_IsOK(res1)) {
26554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26555 }
26556 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26557 if (obj1) {
26558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26559 if (!SWIG_IsOK(ecode2)) {
26560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26561 }
26562 arg2 = static_cast< bool >(val2);
26563 }
26564 {
26565 PyThreadState* __tstate = wxPyBeginAllowThreads();
26566 (arg1)->RequestMore(arg2);
26567 wxPyEndAllowThreads(__tstate);
26568 if (PyErr_Occurred()) SWIG_fail;
26569 }
26570 resultobj = SWIG_Py_Void();
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26578 PyObject *resultobj = 0;
26579 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26580 bool result;
26581 void *argp1 = 0 ;
26582 int res1 = 0 ;
26583 PyObject *swig_obj[1] ;
26584
26585 if (!args) SWIG_fail;
26586 swig_obj[0] = args;
26587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26588 if (!SWIG_IsOK(res1)) {
26589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26590 }
26591 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26592 {
26593 PyThreadState* __tstate = wxPyBeginAllowThreads();
26594 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 {
26599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26600 }
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj = 0;
26609 wxIdleMode arg1 ;
26610 int val1 ;
26611 int ecode1 = 0 ;
26612 PyObject * obj0 = 0 ;
26613 char * kwnames[] = {
26614 (char *) "mode", NULL
26615 };
26616
26617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26618 ecode1 = SWIG_AsVal_int(obj0, &val1);
26619 if (!SWIG_IsOK(ecode1)) {
26620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26621 }
26622 arg1 = static_cast< wxIdleMode >(val1);
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 wxIdleEvent::SetMode(arg1);
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = SWIG_Py_Void();
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26637 PyObject *resultobj = 0;
26638 wxIdleMode result;
26639
26640 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (wxIdleMode)wxIdleEvent::GetMode();
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 resultobj = SWIG_From_int(static_cast< int >(result));
26648 return resultobj;
26649 fail:
26650 return NULL;
26651 }
26652
26653
26654 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26655 PyObject *resultobj = 0;
26656 wxWindow *arg1 = (wxWindow *) 0 ;
26657 bool result;
26658 void *argp1 = 0 ;
26659 int res1 = 0 ;
26660 PyObject * obj0 = 0 ;
26661 char * kwnames[] = {
26662 (char *) "win", NULL
26663 };
26664
26665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26667 if (!SWIG_IsOK(res1)) {
26668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26669 }
26670 arg1 = reinterpret_cast< wxWindow * >(argp1);
26671 {
26672 PyThreadState* __tstate = wxPyBeginAllowThreads();
26673 result = (bool)wxIdleEvent::CanSend(arg1);
26674 wxPyEndAllowThreads(__tstate);
26675 if (PyErr_Occurred()) SWIG_fail;
26676 }
26677 {
26678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26679 }
26680 return resultobj;
26681 fail:
26682 return NULL;
26683 }
26684
26685
26686 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26687 PyObject *obj;
26688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26689 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26690 return SWIG_Py_Void();
26691 }
26692
26693 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26694 return SWIG_Python_InitShadowInstance(args);
26695 }
26696
26697 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26698 PyObject *resultobj = 0;
26699 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26700 int arg2 = (int) 0 ;
26701 wxClipboardTextEvent *result = 0 ;
26702 int val1 ;
26703 int ecode1 = 0 ;
26704 int val2 ;
26705 int ecode2 = 0 ;
26706 PyObject * obj0 = 0 ;
26707 PyObject * obj1 = 0 ;
26708 char * kwnames[] = {
26709 (char *) "type",(char *) "winid", NULL
26710 };
26711
26712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26713 if (obj0) {
26714 ecode1 = SWIG_AsVal_int(obj0, &val1);
26715 if (!SWIG_IsOK(ecode1)) {
26716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26717 }
26718 arg1 = static_cast< wxEventType >(val1);
26719 }
26720 if (obj1) {
26721 ecode2 = SWIG_AsVal_int(obj1, &val2);
26722 if (!SWIG_IsOK(ecode2)) {
26723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26724 }
26725 arg2 = static_cast< int >(val2);
26726 }
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26730 wxPyEndAllowThreads(__tstate);
26731 if (PyErr_Occurred()) SWIG_fail;
26732 }
26733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26734 return resultobj;
26735 fail:
26736 return NULL;
26737 }
26738
26739
26740 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26741 PyObject *obj;
26742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26743 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26744 return SWIG_Py_Void();
26745 }
26746
26747 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26748 return SWIG_Python_InitShadowInstance(args);
26749 }
26750
26751 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj = 0;
26753 int arg1 = (int) 0 ;
26754 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26755 wxPyEvent *result = 0 ;
26756 int val1 ;
26757 int ecode1 = 0 ;
26758 int val2 ;
26759 int ecode2 = 0 ;
26760 PyObject * obj0 = 0 ;
26761 PyObject * obj1 = 0 ;
26762 char * kwnames[] = {
26763 (char *) "winid",(char *) "eventType", NULL
26764 };
26765
26766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26767 if (obj0) {
26768 ecode1 = SWIG_AsVal_int(obj0, &val1);
26769 if (!SWIG_IsOK(ecode1)) {
26770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26771 }
26772 arg1 = static_cast< int >(val1);
26773 }
26774 if (obj1) {
26775 ecode2 = SWIG_AsVal_int(obj1, &val2);
26776 if (!SWIG_IsOK(ecode2)) {
26777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26778 }
26779 arg2 = static_cast< wxEventType >(val2);
26780 }
26781 {
26782 PyThreadState* __tstate = wxPyBeginAllowThreads();
26783 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26784 wxPyEndAllowThreads(__tstate);
26785 if (PyErr_Occurred()) SWIG_fail;
26786 }
26787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26788 return resultobj;
26789 fail:
26790 return NULL;
26791 }
26792
26793
26794 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26795 PyObject *resultobj = 0;
26796 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26797 void *argp1 = 0 ;
26798 int res1 = 0 ;
26799 PyObject *swig_obj[1] ;
26800
26801 if (!args) SWIG_fail;
26802 swig_obj[0] = args;
26803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26804 if (!SWIG_IsOK(res1)) {
26805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26806 }
26807 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 delete arg1;
26811
26812 wxPyEndAllowThreads(__tstate);
26813 if (PyErr_Occurred()) SWIG_fail;
26814 }
26815 resultobj = SWIG_Py_Void();
26816 return resultobj;
26817 fail:
26818 return NULL;
26819 }
26820
26821
26822 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26823 PyObject *resultobj = 0;
26824 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26825 PyObject *arg2 = (PyObject *) 0 ;
26826 void *argp1 = 0 ;
26827 int res1 = 0 ;
26828 PyObject * obj0 = 0 ;
26829 PyObject * obj1 = 0 ;
26830 char * kwnames[] = {
26831 (char *) "self",(char *) "self", NULL
26832 };
26833
26834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26836 if (!SWIG_IsOK(res1)) {
26837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26838 }
26839 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26840 arg2 = obj1;
26841 {
26842 PyThreadState* __tstate = wxPyBeginAllowThreads();
26843 (arg1)->SetSelf(arg2);
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 resultobj = SWIG_Py_Void();
26848 return resultobj;
26849 fail:
26850 return NULL;
26851 }
26852
26853
26854 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26855 PyObject *resultobj = 0;
26856 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26857 PyObject *result = 0 ;
26858 void *argp1 = 0 ;
26859 int res1 = 0 ;
26860 PyObject *swig_obj[1] ;
26861
26862 if (!args) SWIG_fail;
26863 swig_obj[0] = args;
26864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26865 if (!SWIG_IsOK(res1)) {
26866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26867 }
26868 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (PyObject *)(arg1)->GetSelf();
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 resultobj = result;
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26883 PyObject *obj;
26884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26885 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26886 return SWIG_Py_Void();
26887 }
26888
26889 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26890 return SWIG_Python_InitShadowInstance(args);
26891 }
26892
26893 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26894 PyObject *resultobj = 0;
26895 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26896 int arg2 = (int) 0 ;
26897 wxPyCommandEvent *result = 0 ;
26898 int val1 ;
26899 int ecode1 = 0 ;
26900 int val2 ;
26901 int ecode2 = 0 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 char * kwnames[] = {
26905 (char *) "eventType",(char *) "id", NULL
26906 };
26907
26908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26909 if (obj0) {
26910 ecode1 = SWIG_AsVal_int(obj0, &val1);
26911 if (!SWIG_IsOK(ecode1)) {
26912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26913 }
26914 arg1 = static_cast< wxEventType >(val1);
26915 }
26916 if (obj1) {
26917 ecode2 = SWIG_AsVal_int(obj1, &val2);
26918 if (!SWIG_IsOK(ecode2)) {
26919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26920 }
26921 arg2 = static_cast< int >(val2);
26922 }
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26930 return resultobj;
26931 fail:
26932 return NULL;
26933 }
26934
26935
26936 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26937 PyObject *resultobj = 0;
26938 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26939 void *argp1 = 0 ;
26940 int res1 = 0 ;
26941 PyObject *swig_obj[1] ;
26942
26943 if (!args) SWIG_fail;
26944 swig_obj[0] = args;
26945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26946 if (!SWIG_IsOK(res1)) {
26947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26948 }
26949 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 delete arg1;
26953
26954 wxPyEndAllowThreads(__tstate);
26955 if (PyErr_Occurred()) SWIG_fail;
26956 }
26957 resultobj = SWIG_Py_Void();
26958 return resultobj;
26959 fail:
26960 return NULL;
26961 }
26962
26963
26964 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26965 PyObject *resultobj = 0;
26966 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26967 PyObject *arg2 = (PyObject *) 0 ;
26968 void *argp1 = 0 ;
26969 int res1 = 0 ;
26970 PyObject * obj0 = 0 ;
26971 PyObject * obj1 = 0 ;
26972 char * kwnames[] = {
26973 (char *) "self",(char *) "self", NULL
26974 };
26975
26976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26978 if (!SWIG_IsOK(res1)) {
26979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26980 }
26981 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26982 arg2 = obj1;
26983 {
26984 PyThreadState* __tstate = wxPyBeginAllowThreads();
26985 (arg1)->SetSelf(arg2);
26986 wxPyEndAllowThreads(__tstate);
26987 if (PyErr_Occurred()) SWIG_fail;
26988 }
26989 resultobj = SWIG_Py_Void();
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26997 PyObject *resultobj = 0;
26998 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26999 PyObject *result = 0 ;
27000 void *argp1 = 0 ;
27001 int res1 = 0 ;
27002 PyObject *swig_obj[1] ;
27003
27004 if (!args) SWIG_fail;
27005 swig_obj[0] = args;
27006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27007 if (!SWIG_IsOK(res1)) {
27008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27009 }
27010 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27011 {
27012 PyThreadState* __tstate = wxPyBeginAllowThreads();
27013 result = (PyObject *)(arg1)->GetSelf();
27014 wxPyEndAllowThreads(__tstate);
27015 if (PyErr_Occurred()) SWIG_fail;
27016 }
27017 resultobj = result;
27018 return resultobj;
27019 fail:
27020 return NULL;
27021 }
27022
27023
27024 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27025 PyObject *obj;
27026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27027 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27028 return SWIG_Py_Void();
27029 }
27030
27031 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27032 return SWIG_Python_InitShadowInstance(args);
27033 }
27034
27035 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27036 PyObject *resultobj = 0;
27037 wxWindow *arg1 = (wxWindow *) 0 ;
27038 wxDateTime *arg2 = 0 ;
27039 wxEventType arg3 ;
27040 wxDateEvent *result = 0 ;
27041 void *argp1 = 0 ;
27042 int res1 = 0 ;
27043 void *argp2 = 0 ;
27044 int res2 = 0 ;
27045 int val3 ;
27046 int ecode3 = 0 ;
27047 PyObject * obj0 = 0 ;
27048 PyObject * obj1 = 0 ;
27049 PyObject * obj2 = 0 ;
27050 char * kwnames[] = {
27051 (char *) "win",(char *) "dt",(char *) "type", NULL
27052 };
27053
27054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27058 }
27059 arg1 = reinterpret_cast< wxWindow * >(argp1);
27060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27061 if (!SWIG_IsOK(res2)) {
27062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27063 }
27064 if (!argp2) {
27065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27066 }
27067 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27068 ecode3 = SWIG_AsVal_int(obj2, &val3);
27069 if (!SWIG_IsOK(ecode3)) {
27070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27071 }
27072 arg3 = static_cast< wxEventType >(val3);
27073 {
27074 PyThreadState* __tstate = wxPyBeginAllowThreads();
27075 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27080 return resultobj;
27081 fail:
27082 return NULL;
27083 }
27084
27085
27086 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27087 PyObject *resultobj = 0;
27088 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27089 wxDateTime *result = 0 ;
27090 void *argp1 = 0 ;
27091 int res1 = 0 ;
27092 PyObject *swig_obj[1] ;
27093
27094 if (!args) SWIG_fail;
27095 swig_obj[0] = args;
27096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27097 if (!SWIG_IsOK(res1)) {
27098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27099 }
27100 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 {
27104 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27105 result = (wxDateTime *) &_result_ref;
27106 }
27107 wxPyEndAllowThreads(__tstate);
27108 if (PyErr_Occurred()) SWIG_fail;
27109 }
27110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27111 return resultobj;
27112 fail:
27113 return NULL;
27114 }
27115
27116
27117 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27118 PyObject *resultobj = 0;
27119 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27120 wxDateTime *arg2 = 0 ;
27121 void *argp1 = 0 ;
27122 int res1 = 0 ;
27123 void *argp2 = 0 ;
27124 int res2 = 0 ;
27125 PyObject * obj0 = 0 ;
27126 PyObject * obj1 = 0 ;
27127 char * kwnames[] = {
27128 (char *) "self",(char *) "date", NULL
27129 };
27130
27131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27133 if (!SWIG_IsOK(res1)) {
27134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27135 }
27136 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27137 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27138 if (!SWIG_IsOK(res2)) {
27139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27140 }
27141 if (!argp2) {
27142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27143 }
27144 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 (arg1)->SetDate((wxDateTime const &)*arg2);
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 resultobj = SWIG_Py_Void();
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27159 PyObject *obj;
27160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27161 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27162 return SWIG_Py_Void();
27163 }
27164
27165 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27166 return SWIG_Python_InitShadowInstance(args);
27167 }
27168
27169 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27170 PyObject *resultobj = 0;
27171 wxPyApp *result = 0 ;
27172
27173 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 result = (wxPyApp *)new_wxPyApp();
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27181 return resultobj;
27182 fail:
27183 return NULL;
27184 }
27185
27186
27187 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27188 PyObject *resultobj = 0;
27189 wxPyApp *arg1 = (wxPyApp *) 0 ;
27190 void *argp1 = 0 ;
27191 int res1 = 0 ;
27192 PyObject *swig_obj[1] ;
27193
27194 if (!args) SWIG_fail;
27195 swig_obj[0] = args;
27196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27197 if (!SWIG_IsOK(res1)) {
27198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27199 }
27200 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27201 {
27202 PyThreadState* __tstate = wxPyBeginAllowThreads();
27203 delete arg1;
27204
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 resultobj = SWIG_Py_Void();
27209 return resultobj;
27210 fail:
27211 return NULL;
27212 }
27213
27214
27215 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27216 PyObject *resultobj = 0;
27217 wxPyApp *arg1 = (wxPyApp *) 0 ;
27218 PyObject *arg2 = (PyObject *) 0 ;
27219 PyObject *arg3 = (PyObject *) 0 ;
27220 bool arg4 ;
27221 void *argp1 = 0 ;
27222 int res1 = 0 ;
27223 bool val4 ;
27224 int ecode4 = 0 ;
27225 PyObject * obj0 = 0 ;
27226 PyObject * obj1 = 0 ;
27227 PyObject * obj2 = 0 ;
27228 PyObject * obj3 = 0 ;
27229 char * kwnames[] = {
27230 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27231 };
27232
27233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27235 if (!SWIG_IsOK(res1)) {
27236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27237 }
27238 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27239 arg2 = obj1;
27240 arg3 = obj2;
27241 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27242 if (!SWIG_IsOK(ecode4)) {
27243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27244 }
27245 arg4 = static_cast< bool >(val4);
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 resultobj = SWIG_Py_Void();
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27260 PyObject *resultobj = 0;
27261 wxPyApp *arg1 = (wxPyApp *) 0 ;
27262 wxString result;
27263 void *argp1 = 0 ;
27264 int res1 = 0 ;
27265 PyObject *swig_obj[1] ;
27266
27267 if (!args) SWIG_fail;
27268 swig_obj[0] = args;
27269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27270 if (!SWIG_IsOK(res1)) {
27271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27272 }
27273 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 result = ((wxPyApp const *)arg1)->GetAppName();
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 {
27281 #if wxUSE_UNICODE
27282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27283 #else
27284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27285 #endif
27286 }
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27294 PyObject *resultobj = 0;
27295 wxPyApp *arg1 = (wxPyApp *) 0 ;
27296 wxString *arg2 = 0 ;
27297 void *argp1 = 0 ;
27298 int res1 = 0 ;
27299 bool temp2 = false ;
27300 PyObject * obj0 = 0 ;
27301 PyObject * obj1 = 0 ;
27302 char * kwnames[] = {
27303 (char *) "self",(char *) "name", NULL
27304 };
27305
27306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27310 }
27311 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27312 {
27313 arg2 = wxString_in_helper(obj1);
27314 if (arg2 == NULL) SWIG_fail;
27315 temp2 = true;
27316 }
27317 {
27318 PyThreadState* __tstate = wxPyBeginAllowThreads();
27319 (arg1)->SetAppName((wxString const &)*arg2);
27320 wxPyEndAllowThreads(__tstate);
27321 if (PyErr_Occurred()) SWIG_fail;
27322 }
27323 resultobj = SWIG_Py_Void();
27324 {
27325 if (temp2)
27326 delete arg2;
27327 }
27328 return resultobj;
27329 fail:
27330 {
27331 if (temp2)
27332 delete arg2;
27333 }
27334 return NULL;
27335 }
27336
27337
27338 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27339 PyObject *resultobj = 0;
27340 wxPyApp *arg1 = (wxPyApp *) 0 ;
27341 wxString result;
27342 void *argp1 = 0 ;
27343 int res1 = 0 ;
27344 PyObject *swig_obj[1] ;
27345
27346 if (!args) SWIG_fail;
27347 swig_obj[0] = args;
27348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27349 if (!SWIG_IsOK(res1)) {
27350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27351 }
27352 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27353 {
27354 PyThreadState* __tstate = wxPyBeginAllowThreads();
27355 result = ((wxPyApp const *)arg1)->GetClassName();
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 {
27360 #if wxUSE_UNICODE
27361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27362 #else
27363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27364 #endif
27365 }
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27373 PyObject *resultobj = 0;
27374 wxPyApp *arg1 = (wxPyApp *) 0 ;
27375 wxString *arg2 = 0 ;
27376 void *argp1 = 0 ;
27377 int res1 = 0 ;
27378 bool temp2 = false ;
27379 PyObject * obj0 = 0 ;
27380 PyObject * obj1 = 0 ;
27381 char * kwnames[] = {
27382 (char *) "self",(char *) "name", NULL
27383 };
27384
27385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27387 if (!SWIG_IsOK(res1)) {
27388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27389 }
27390 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27391 {
27392 arg2 = wxString_in_helper(obj1);
27393 if (arg2 == NULL) SWIG_fail;
27394 temp2 = true;
27395 }
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 (arg1)->SetClassName((wxString const &)*arg2);
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 resultobj = SWIG_Py_Void();
27403 {
27404 if (temp2)
27405 delete arg2;
27406 }
27407 return resultobj;
27408 fail:
27409 {
27410 if (temp2)
27411 delete arg2;
27412 }
27413 return NULL;
27414 }
27415
27416
27417 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27418 PyObject *resultobj = 0;
27419 wxPyApp *arg1 = (wxPyApp *) 0 ;
27420 wxString *result = 0 ;
27421 void *argp1 = 0 ;
27422 int res1 = 0 ;
27423 PyObject *swig_obj[1] ;
27424
27425 if (!args) SWIG_fail;
27426 swig_obj[0] = args;
27427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27428 if (!SWIG_IsOK(res1)) {
27429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27430 }
27431 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27432 {
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 {
27435 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27436 result = (wxString *) &_result_ref;
27437 }
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 {
27442 #if wxUSE_UNICODE
27443 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27444 #else
27445 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27446 #endif
27447 }
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27455 PyObject *resultobj = 0;
27456 wxPyApp *arg1 = (wxPyApp *) 0 ;
27457 wxString *arg2 = 0 ;
27458 void *argp1 = 0 ;
27459 int res1 = 0 ;
27460 bool temp2 = false ;
27461 PyObject * obj0 = 0 ;
27462 PyObject * obj1 = 0 ;
27463 char * kwnames[] = {
27464 (char *) "self",(char *) "name", NULL
27465 };
27466
27467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27469 if (!SWIG_IsOK(res1)) {
27470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27471 }
27472 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27473 {
27474 arg2 = wxString_in_helper(obj1);
27475 if (arg2 == NULL) SWIG_fail;
27476 temp2 = true;
27477 }
27478 {
27479 PyThreadState* __tstate = wxPyBeginAllowThreads();
27480 (arg1)->SetVendorName((wxString const &)*arg2);
27481 wxPyEndAllowThreads(__tstate);
27482 if (PyErr_Occurred()) SWIG_fail;
27483 }
27484 resultobj = SWIG_Py_Void();
27485 {
27486 if (temp2)
27487 delete arg2;
27488 }
27489 return resultobj;
27490 fail:
27491 {
27492 if (temp2)
27493 delete arg2;
27494 }
27495 return NULL;
27496 }
27497
27498
27499 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27500 PyObject *resultobj = 0;
27501 wxPyApp *arg1 = (wxPyApp *) 0 ;
27502 wxAppTraits *result = 0 ;
27503 void *argp1 = 0 ;
27504 int res1 = 0 ;
27505 PyObject *swig_obj[1] ;
27506
27507 if (!args) SWIG_fail;
27508 swig_obj[0] = args;
27509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27510 if (!SWIG_IsOK(res1)) {
27511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27512 }
27513 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = (wxAppTraits *)(arg1)->GetTraits();
27517 wxPyEndAllowThreads(__tstate);
27518 if (PyErr_Occurred()) SWIG_fail;
27519 }
27520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27528 PyObject *resultobj = 0;
27529 wxPyApp *arg1 = (wxPyApp *) 0 ;
27530 void *argp1 = 0 ;
27531 int res1 = 0 ;
27532 PyObject *swig_obj[1] ;
27533
27534 if (!args) SWIG_fail;
27535 swig_obj[0] = args;
27536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27537 if (!SWIG_IsOK(res1)) {
27538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27539 }
27540 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 (arg1)->ProcessPendingEvents();
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 resultobj = SWIG_Py_Void();
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj = 0;
27556 wxPyApp *arg1 = (wxPyApp *) 0 ;
27557 bool arg2 = (bool) false ;
27558 bool result;
27559 void *argp1 = 0 ;
27560 int res1 = 0 ;
27561 bool val2 ;
27562 int ecode2 = 0 ;
27563 PyObject * obj0 = 0 ;
27564 PyObject * obj1 = 0 ;
27565 char * kwnames[] = {
27566 (char *) "self",(char *) "onlyIfNeeded", NULL
27567 };
27568
27569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27571 if (!SWIG_IsOK(res1)) {
27572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27573 }
27574 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27575 if (obj1) {
27576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27577 if (!SWIG_IsOK(ecode2)) {
27578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27579 }
27580 arg2 = static_cast< bool >(val2);
27581 }
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (bool)(arg1)->Yield(arg2);
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 {
27589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27590 }
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27598 PyObject *resultobj = 0;
27599 wxPyApp *arg1 = (wxPyApp *) 0 ;
27600 void *argp1 = 0 ;
27601 int res1 = 0 ;
27602 PyObject *swig_obj[1] ;
27603
27604 if (!args) SWIG_fail;
27605 swig_obj[0] = args;
27606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27607 if (!SWIG_IsOK(res1)) {
27608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27609 }
27610 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27611 {
27612 PyThreadState* __tstate = wxPyBeginAllowThreads();
27613 (arg1)->WakeUpIdle();
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 resultobj = SWIG_Py_Void();
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27625 PyObject *resultobj = 0;
27626 bool result;
27627
27628 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 result = (bool)wxPyApp::IsMainLoopRunning();
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 {
27636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27637 }
27638 return resultobj;
27639 fail:
27640 return NULL;
27641 }
27642
27643
27644 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27645 PyObject *resultobj = 0;
27646 wxPyApp *arg1 = (wxPyApp *) 0 ;
27647 int result;
27648 void *argp1 = 0 ;
27649 int res1 = 0 ;
27650 PyObject *swig_obj[1] ;
27651
27652 if (!args) SWIG_fail;
27653 swig_obj[0] = args;
27654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27655 if (!SWIG_IsOK(res1)) {
27656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27657 }
27658 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 result = (int)(arg1)->MainLoop();
27662 wxPyEndAllowThreads(__tstate);
27663 if (PyErr_Occurred()) SWIG_fail;
27664 }
27665 resultobj = SWIG_From_int(static_cast< int >(result));
27666 return resultobj;
27667 fail:
27668 return NULL;
27669 }
27670
27671
27672 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27673 PyObject *resultobj = 0;
27674 wxPyApp *arg1 = (wxPyApp *) 0 ;
27675 void *argp1 = 0 ;
27676 int res1 = 0 ;
27677 PyObject *swig_obj[1] ;
27678
27679 if (!args) SWIG_fail;
27680 swig_obj[0] = args;
27681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27682 if (!SWIG_IsOK(res1)) {
27683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27684 }
27685 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 (arg1)->Exit();
27689 wxPyEndAllowThreads(__tstate);
27690 if (PyErr_Occurred()) SWIG_fail;
27691 }
27692 resultobj = SWIG_Py_Void();
27693 return resultobj;
27694 fail:
27695 return NULL;
27696 }
27697
27698
27699 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27700 PyObject *resultobj = 0;
27701 wxPyApp *arg1 = (wxPyApp *) 0 ;
27702 void *argp1 = 0 ;
27703 int res1 = 0 ;
27704 PyObject *swig_obj[1] ;
27705
27706 if (!args) SWIG_fail;
27707 swig_obj[0] = args;
27708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27709 if (!SWIG_IsOK(res1)) {
27710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27711 }
27712 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 (arg1)->ExitMainLoop();
27716 wxPyEndAllowThreads(__tstate);
27717 if (PyErr_Occurred()) SWIG_fail;
27718 }
27719 resultobj = SWIG_Py_Void();
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27727 PyObject *resultobj = 0;
27728 wxPyApp *arg1 = (wxPyApp *) 0 ;
27729 bool result;
27730 void *argp1 = 0 ;
27731 int res1 = 0 ;
27732 PyObject *swig_obj[1] ;
27733
27734 if (!args) SWIG_fail;
27735 swig_obj[0] = args;
27736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27737 if (!SWIG_IsOK(res1)) {
27738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27739 }
27740 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 result = (bool)(arg1)->Pending();
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 {
27748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27749 }
27750 return resultobj;
27751 fail:
27752 return NULL;
27753 }
27754
27755
27756 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27757 PyObject *resultobj = 0;
27758 wxPyApp *arg1 = (wxPyApp *) 0 ;
27759 bool result;
27760 void *argp1 = 0 ;
27761 int res1 = 0 ;
27762 PyObject *swig_obj[1] ;
27763
27764 if (!args) SWIG_fail;
27765 swig_obj[0] = args;
27766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27767 if (!SWIG_IsOK(res1)) {
27768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27769 }
27770 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27771 {
27772 PyThreadState* __tstate = wxPyBeginAllowThreads();
27773 result = (bool)(arg1)->Dispatch();
27774 wxPyEndAllowThreads(__tstate);
27775 if (PyErr_Occurred()) SWIG_fail;
27776 }
27777 {
27778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27779 }
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27787 PyObject *resultobj = 0;
27788 wxPyApp *arg1 = (wxPyApp *) 0 ;
27789 bool result;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 PyObject *swig_obj[1] ;
27793
27794 if (!args) SWIG_fail;
27795 swig_obj[0] = args;
27796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27797 if (!SWIG_IsOK(res1)) {
27798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27799 }
27800 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (bool)(arg1)->ProcessIdle();
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj = 0;
27818 wxPyApp *arg1 = (wxPyApp *) 0 ;
27819 wxWindow *arg2 = (wxWindow *) 0 ;
27820 wxIdleEvent *arg3 = 0 ;
27821 bool result;
27822 void *argp1 = 0 ;
27823 int res1 = 0 ;
27824 void *argp2 = 0 ;
27825 int res2 = 0 ;
27826 void *argp3 = 0 ;
27827 int res3 = 0 ;
27828 PyObject * obj0 = 0 ;
27829 PyObject * obj1 = 0 ;
27830 PyObject * obj2 = 0 ;
27831 char * kwnames[] = {
27832 (char *) "self",(char *) "win",(char *) "event", NULL
27833 };
27834
27835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27837 if (!SWIG_IsOK(res1)) {
27838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27839 }
27840 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27842 if (!SWIG_IsOK(res2)) {
27843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27844 }
27845 arg2 = reinterpret_cast< wxWindow * >(argp2);
27846 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27847 if (!SWIG_IsOK(res3)) {
27848 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27849 }
27850 if (!argp3) {
27851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27852 }
27853 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 {
27861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27862 }
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27870 PyObject *resultobj = 0;
27871 wxPyApp *arg1 = (wxPyApp *) 0 ;
27872 bool result;
27873 void *argp1 = 0 ;
27874 int res1 = 0 ;
27875 PyObject *swig_obj[1] ;
27876
27877 if (!args) SWIG_fail;
27878 swig_obj[0] = args;
27879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27880 if (!SWIG_IsOK(res1)) {
27881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27882 }
27883 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 result = (bool)((wxPyApp const *)arg1)->IsActive();
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 {
27891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27892 }
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27900 PyObject *resultobj = 0;
27901 wxPyApp *arg1 = (wxPyApp *) 0 ;
27902 wxWindow *arg2 = (wxWindow *) 0 ;
27903 void *argp1 = 0 ;
27904 int res1 = 0 ;
27905 void *argp2 = 0 ;
27906 int res2 = 0 ;
27907 PyObject * obj0 = 0 ;
27908 PyObject * obj1 = 0 ;
27909 char * kwnames[] = {
27910 (char *) "self",(char *) "win", NULL
27911 };
27912
27913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27915 if (!SWIG_IsOK(res1)) {
27916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27917 }
27918 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27920 if (!SWIG_IsOK(res2)) {
27921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27922 }
27923 arg2 = reinterpret_cast< wxWindow * >(argp2);
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 (arg1)->SetTopWindow(arg2);
27927 wxPyEndAllowThreads(__tstate);
27928 if (PyErr_Occurred()) SWIG_fail;
27929 }
27930 resultobj = SWIG_Py_Void();
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27938 PyObject *resultobj = 0;
27939 wxPyApp *arg1 = (wxPyApp *) 0 ;
27940 wxWindow *result = 0 ;
27941 void *argp1 = 0 ;
27942 int res1 = 0 ;
27943 PyObject *swig_obj[1] ;
27944
27945 if (!args) SWIG_fail;
27946 swig_obj[0] = args;
27947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27948 if (!SWIG_IsOK(res1)) {
27949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27950 }
27951 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27952 {
27953 PyThreadState* __tstate = wxPyBeginAllowThreads();
27954 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 {
27959 resultobj = wxPyMake_wxObject(result, (bool)0);
27960 }
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj = 0;
27969 wxPyApp *arg1 = (wxPyApp *) 0 ;
27970 bool arg2 ;
27971 void *argp1 = 0 ;
27972 int res1 = 0 ;
27973 bool val2 ;
27974 int ecode2 = 0 ;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 char * kwnames[] = {
27978 (char *) "self",(char *) "flag", NULL
27979 };
27980
27981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27983 if (!SWIG_IsOK(res1)) {
27984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27985 }
27986 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27988 if (!SWIG_IsOK(ecode2)) {
27989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27990 }
27991 arg2 = static_cast< bool >(val2);
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 (arg1)->SetExitOnFrameDelete(arg2);
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 resultobj = SWIG_Py_Void();
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28006 PyObject *resultobj = 0;
28007 wxPyApp *arg1 = (wxPyApp *) 0 ;
28008 bool result;
28009 void *argp1 = 0 ;
28010 int res1 = 0 ;
28011 PyObject *swig_obj[1] ;
28012
28013 if (!args) SWIG_fail;
28014 swig_obj[0] = args;
28015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28016 if (!SWIG_IsOK(res1)) {
28017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28018 }
28019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28020 {
28021 PyThreadState* __tstate = wxPyBeginAllowThreads();
28022 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28023 wxPyEndAllowThreads(__tstate);
28024 if (PyErr_Occurred()) SWIG_fail;
28025 }
28026 {
28027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28028 }
28029 return resultobj;
28030 fail:
28031 return NULL;
28032 }
28033
28034
28035 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28036 PyObject *resultobj = 0;
28037 wxPyApp *arg1 = (wxPyApp *) 0 ;
28038 bool arg2 ;
28039 void *argp1 = 0 ;
28040 int res1 = 0 ;
28041 bool val2 ;
28042 int ecode2 = 0 ;
28043 PyObject * obj0 = 0 ;
28044 PyObject * obj1 = 0 ;
28045 char * kwnames[] = {
28046 (char *) "self",(char *) "flag", NULL
28047 };
28048
28049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28053 }
28054 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28056 if (!SWIG_IsOK(ecode2)) {
28057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28058 }
28059 arg2 = static_cast< bool >(val2);
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 (arg1)->SetUseBestVisual(arg2);
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_Py_Void();
28067 return resultobj;
28068 fail:
28069 return NULL;
28070 }
28071
28072
28073 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28074 PyObject *resultobj = 0;
28075 wxPyApp *arg1 = (wxPyApp *) 0 ;
28076 bool result;
28077 void *argp1 = 0 ;
28078 int res1 = 0 ;
28079 PyObject *swig_obj[1] ;
28080
28081 if (!args) SWIG_fail;
28082 swig_obj[0] = args;
28083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28084 if (!SWIG_IsOK(res1)) {
28085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28086 }
28087 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28088 {
28089 PyThreadState* __tstate = wxPyBeginAllowThreads();
28090 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28091 wxPyEndAllowThreads(__tstate);
28092 if (PyErr_Occurred()) SWIG_fail;
28093 }
28094 {
28095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28096 }
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 wxPyApp *arg1 = (wxPyApp *) 0 ;
28106 int arg2 ;
28107 void *argp1 = 0 ;
28108 int res1 = 0 ;
28109 int val2 ;
28110 int ecode2 = 0 ;
28111 PyObject * obj0 = 0 ;
28112 PyObject * obj1 = 0 ;
28113 char * kwnames[] = {
28114 (char *) "self",(char *) "mode", NULL
28115 };
28116
28117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28119 if (!SWIG_IsOK(res1)) {
28120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28121 }
28122 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28123 ecode2 = SWIG_AsVal_int(obj1, &val2);
28124 if (!SWIG_IsOK(ecode2)) {
28125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28126 }
28127 arg2 = static_cast< int >(val2);
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 (arg1)->SetPrintMode(arg2);
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 resultobj = SWIG_Py_Void();
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28142 PyObject *resultobj = 0;
28143 wxPyApp *arg1 = (wxPyApp *) 0 ;
28144 int result;
28145 void *argp1 = 0 ;
28146 int res1 = 0 ;
28147 PyObject *swig_obj[1] ;
28148
28149 if (!args) SWIG_fail;
28150 swig_obj[0] = args;
28151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28152 if (!SWIG_IsOK(res1)) {
28153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28154 }
28155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28156 {
28157 PyThreadState* __tstate = wxPyBeginAllowThreads();
28158 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28159 wxPyEndAllowThreads(__tstate);
28160 if (PyErr_Occurred()) SWIG_fail;
28161 }
28162 resultobj = SWIG_From_int(static_cast< int >(result));
28163 return resultobj;
28164 fail:
28165 return NULL;
28166 }
28167
28168
28169 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28170 PyObject *resultobj = 0;
28171 wxPyApp *arg1 = (wxPyApp *) 0 ;
28172 int arg2 ;
28173 void *argp1 = 0 ;
28174 int res1 = 0 ;
28175 int val2 ;
28176 int ecode2 = 0 ;
28177 PyObject * obj0 = 0 ;
28178 PyObject * obj1 = 0 ;
28179 char * kwnames[] = {
28180 (char *) "self",(char *) "mode", NULL
28181 };
28182
28183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28185 if (!SWIG_IsOK(res1)) {
28186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28187 }
28188 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28189 ecode2 = SWIG_AsVal_int(obj1, &val2);
28190 if (!SWIG_IsOK(ecode2)) {
28191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28192 }
28193 arg2 = static_cast< int >(val2);
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 (arg1)->SetAssertMode(arg2);
28197 wxPyEndAllowThreads(__tstate);
28198 if (PyErr_Occurred()) SWIG_fail;
28199 }
28200 resultobj = SWIG_Py_Void();
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28208 PyObject *resultobj = 0;
28209 wxPyApp *arg1 = (wxPyApp *) 0 ;
28210 int result;
28211 void *argp1 = 0 ;
28212 int res1 = 0 ;
28213 PyObject *swig_obj[1] ;
28214
28215 if (!args) SWIG_fail;
28216 swig_obj[0] = args;
28217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28218 if (!SWIG_IsOK(res1)) {
28219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28220 }
28221 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (int)(arg1)->GetAssertMode();
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 resultobj = SWIG_From_int(static_cast< int >(result));
28229 return resultobj;
28230 fail:
28231 return NULL;
28232 }
28233
28234
28235 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28236 PyObject *resultobj = 0;
28237 bool result;
28238
28239 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 {
28247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28248 }
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28256 PyObject *resultobj = 0;
28257 long result;
28258
28259 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28260 {
28261 PyThreadState* __tstate = wxPyBeginAllowThreads();
28262 result = (long)wxPyApp::GetMacAboutMenuItemId();
28263 wxPyEndAllowThreads(__tstate);
28264 if (PyErr_Occurred()) SWIG_fail;
28265 }
28266 resultobj = SWIG_From_long(static_cast< long >(result));
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28274 PyObject *resultobj = 0;
28275 long result;
28276
28277 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28278 {
28279 PyThreadState* __tstate = wxPyBeginAllowThreads();
28280 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 resultobj = SWIG_From_long(static_cast< long >(result));
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28292 PyObject *resultobj = 0;
28293 long result;
28294
28295 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 result = (long)wxPyApp::GetMacExitMenuItemId();
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 resultobj = SWIG_From_long(static_cast< long >(result));
28303 return resultobj;
28304 fail:
28305 return NULL;
28306 }
28307
28308
28309 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28310 PyObject *resultobj = 0;
28311 wxString result;
28312
28313 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28314 {
28315 PyThreadState* __tstate = wxPyBeginAllowThreads();
28316 result = wxPyApp::GetMacHelpMenuTitleName();
28317 wxPyEndAllowThreads(__tstate);
28318 if (PyErr_Occurred()) SWIG_fail;
28319 }
28320 {
28321 #if wxUSE_UNICODE
28322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28323 #else
28324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28325 #endif
28326 }
28327 return resultobj;
28328 fail:
28329 return NULL;
28330 }
28331
28332
28333 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28334 PyObject *resultobj = 0;
28335 bool arg1 ;
28336 bool val1 ;
28337 int ecode1 = 0 ;
28338 PyObject * obj0 = 0 ;
28339 char * kwnames[] = {
28340 (char *) "val", NULL
28341 };
28342
28343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28344 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28345 if (!SWIG_IsOK(ecode1)) {
28346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28347 }
28348 arg1 = static_cast< bool >(val1);
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 resultobj = SWIG_Py_Void();
28356 return resultobj;
28357 fail:
28358 return NULL;
28359 }
28360
28361
28362 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28363 PyObject *resultobj = 0;
28364 long arg1 ;
28365 long val1 ;
28366 int ecode1 = 0 ;
28367 PyObject * obj0 = 0 ;
28368 char * kwnames[] = {
28369 (char *) "val", NULL
28370 };
28371
28372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28373 ecode1 = SWIG_AsVal_long(obj0, &val1);
28374 if (!SWIG_IsOK(ecode1)) {
28375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28376 }
28377 arg1 = static_cast< long >(val1);
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 wxPyApp::SetMacAboutMenuItemId(arg1);
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 resultobj = SWIG_Py_Void();
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28392 PyObject *resultobj = 0;
28393 long arg1 ;
28394 long val1 ;
28395 int ecode1 = 0 ;
28396 PyObject * obj0 = 0 ;
28397 char * kwnames[] = {
28398 (char *) "val", NULL
28399 };
28400
28401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28402 ecode1 = SWIG_AsVal_long(obj0, &val1);
28403 if (!SWIG_IsOK(ecode1)) {
28404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28405 }
28406 arg1 = static_cast< long >(val1);
28407 {
28408 PyThreadState* __tstate = wxPyBeginAllowThreads();
28409 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28410 wxPyEndAllowThreads(__tstate);
28411 if (PyErr_Occurred()) SWIG_fail;
28412 }
28413 resultobj = SWIG_Py_Void();
28414 return resultobj;
28415 fail:
28416 return NULL;
28417 }
28418
28419
28420 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28421 PyObject *resultobj = 0;
28422 long arg1 ;
28423 long val1 ;
28424 int ecode1 = 0 ;
28425 PyObject * obj0 = 0 ;
28426 char * kwnames[] = {
28427 (char *) "val", NULL
28428 };
28429
28430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28431 ecode1 = SWIG_AsVal_long(obj0, &val1);
28432 if (!SWIG_IsOK(ecode1)) {
28433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28434 }
28435 arg1 = static_cast< long >(val1);
28436 {
28437 PyThreadState* __tstate = wxPyBeginAllowThreads();
28438 wxPyApp::SetMacExitMenuItemId(arg1);
28439 wxPyEndAllowThreads(__tstate);
28440 if (PyErr_Occurred()) SWIG_fail;
28441 }
28442 resultobj = SWIG_Py_Void();
28443 return resultobj;
28444 fail:
28445 return NULL;
28446 }
28447
28448
28449 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28450 PyObject *resultobj = 0;
28451 wxString *arg1 = 0 ;
28452 bool temp1 = false ;
28453 PyObject * obj0 = 0 ;
28454 char * kwnames[] = {
28455 (char *) "val", NULL
28456 };
28457
28458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28459 {
28460 arg1 = wxString_in_helper(obj0);
28461 if (arg1 == NULL) SWIG_fail;
28462 temp1 = true;
28463 }
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 resultobj = SWIG_Py_Void();
28471 {
28472 if (temp1)
28473 delete arg1;
28474 }
28475 return resultobj;
28476 fail:
28477 {
28478 if (temp1)
28479 delete arg1;
28480 }
28481 return NULL;
28482 }
28483
28484
28485 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28486 PyObject *resultobj = 0;
28487 wxPyApp *arg1 = (wxPyApp *) 0 ;
28488 void *argp1 = 0 ;
28489 int res1 = 0 ;
28490 PyObject *swig_obj[1] ;
28491
28492 if (!args) SWIG_fail;
28493 swig_obj[0] = args;
28494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28495 if (!SWIG_IsOK(res1)) {
28496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28497 }
28498 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28499 {
28500 PyThreadState* __tstate = wxPyBeginAllowThreads();
28501 (arg1)->_BootstrapApp();
28502 wxPyEndAllowThreads(__tstate);
28503 if (PyErr_Occurred()) SWIG_fail;
28504 }
28505 resultobj = SWIG_Py_Void();
28506 return resultobj;
28507 fail:
28508 return NULL;
28509 }
28510
28511
28512 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28513 PyObject *resultobj = 0;
28514 int result;
28515
28516 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28517 {
28518 PyThreadState* __tstate = wxPyBeginAllowThreads();
28519 result = (int)wxPyApp::GetComCtl32Version();
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 resultobj = SWIG_From_int(static_cast< int >(result));
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28531 PyObject *resultobj = 0;
28532 bool result;
28533
28534 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28535 {
28536 PyThreadState* __tstate = wxPyBeginAllowThreads();
28537 result = (bool)wxPyApp_DisplayAvailable();
28538 wxPyEndAllowThreads(__tstate);
28539 if (PyErr_Occurred()) SWIG_fail;
28540 }
28541 {
28542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28543 }
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28551 PyObject *obj;
28552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28553 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28554 return SWIG_Py_Void();
28555 }
28556
28557 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28558 return SWIG_Python_InitShadowInstance(args);
28559 }
28560
28561 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28562 PyObject *resultobj = 0;
28563
28564 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 wxExit();
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 resultobj = SWIG_Py_Void();
28572 return resultobj;
28573 fail:
28574 return NULL;
28575 }
28576
28577
28578 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28579 PyObject *resultobj = 0;
28580 bool result;
28581
28582 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28583 {
28584 PyThreadState* __tstate = wxPyBeginAllowThreads();
28585 result = (bool)wxYield();
28586 wxPyEndAllowThreads(__tstate);
28587 if (PyErr_Occurred()) SWIG_fail;
28588 }
28589 {
28590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28591 }
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28599 PyObject *resultobj = 0;
28600 bool result;
28601
28602 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (bool)wxYieldIfNeeded();
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj = 0;
28620 wxWindow *arg1 = (wxWindow *) NULL ;
28621 bool arg2 = (bool) false ;
28622 bool result;
28623 void *argp1 = 0 ;
28624 int res1 = 0 ;
28625 bool val2 ;
28626 int ecode2 = 0 ;
28627 PyObject * obj0 = 0 ;
28628 PyObject * obj1 = 0 ;
28629 char * kwnames[] = {
28630 (char *) "win",(char *) "onlyIfNeeded", NULL
28631 };
28632
28633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28634 if (obj0) {
28635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28636 if (!SWIG_IsOK(res1)) {
28637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28638 }
28639 arg1 = reinterpret_cast< wxWindow * >(argp1);
28640 }
28641 if (obj1) {
28642 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28643 if (!SWIG_IsOK(ecode2)) {
28644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28645 }
28646 arg2 = static_cast< bool >(val2);
28647 }
28648 {
28649 PyThreadState* __tstate = wxPyBeginAllowThreads();
28650 result = (bool)wxSafeYield(arg1,arg2);
28651 wxPyEndAllowThreads(__tstate);
28652 if (PyErr_Occurred()) SWIG_fail;
28653 }
28654 {
28655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28656 }
28657 return resultobj;
28658 fail:
28659 return NULL;
28660 }
28661
28662
28663 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28664 PyObject *resultobj = 0;
28665
28666 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 wxWakeUpIdle();
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_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28681 PyObject *resultobj = 0;
28682 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28683 wxEvent *arg2 = 0 ;
28684 void *argp1 = 0 ;
28685 int res1 = 0 ;
28686 void *argp2 = 0 ;
28687 int res2 = 0 ;
28688 PyObject * obj0 = 0 ;
28689 PyObject * obj1 = 0 ;
28690 char * kwnames[] = {
28691 (char *) "dest",(char *) "event", NULL
28692 };
28693
28694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28696 if (!SWIG_IsOK(res1)) {
28697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28698 }
28699 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28700 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28701 if (!SWIG_IsOK(res2)) {
28702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28703 }
28704 if (!argp2) {
28705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28706 }
28707 arg2 = reinterpret_cast< wxEvent * >(argp2);
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 wxPostEvent(arg1,*arg2);
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 resultobj = SWIG_Py_Void();
28715 return resultobj;
28716 fail:
28717 return NULL;
28718 }
28719
28720
28721 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28722 PyObject *resultobj = 0;
28723
28724 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 wxApp_CleanUp();
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 resultobj = SWIG_Py_Void();
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28739 PyObject *resultobj = 0;
28740 wxPyApp *result = 0 ;
28741
28742 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (wxPyApp *)wxPyGetApp();
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 {
28750 resultobj = wxPyMake_wxObject(result, 0);
28751 }
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj = 0;
28760 char *arg1 = (char *) 0 ;
28761 int res1 ;
28762 char *buf1 = 0 ;
28763 int alloc1 = 0 ;
28764 PyObject * obj0 = 0 ;
28765 char * kwnames[] = {
28766 (char *) "encoding", NULL
28767 };
28768
28769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28770 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28771 if (!SWIG_IsOK(res1)) {
28772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28773 }
28774 arg1 = buf1;
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 wxSetDefaultPyEncoding((char const *)arg1);
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 resultobj = SWIG_Py_Void();
28782 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28783 return resultobj;
28784 fail:
28785 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28786 return NULL;
28787 }
28788
28789
28790 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28791 PyObject *resultobj = 0;
28792 char *result = 0 ;
28793
28794 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (char *)wxGetDefaultPyEncoding();
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 resultobj = SWIG_FromCharPtr(result);
28802 return resultobj;
28803 fail:
28804 return NULL;
28805 }
28806
28807
28808 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28809 PyObject *resultobj = 0;
28810 wxEventLoop *result = 0 ;
28811
28812 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 result = (wxEventLoop *)new wxEventLoop();
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28827 PyObject *resultobj = 0;
28828 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28829 void *argp1 = 0 ;
28830 int res1 = 0 ;
28831 PyObject *swig_obj[1] ;
28832
28833 if (!args) SWIG_fail;
28834 swig_obj[0] = args;
28835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28836 if (!SWIG_IsOK(res1)) {
28837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28838 }
28839 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28840 {
28841 PyThreadState* __tstate = wxPyBeginAllowThreads();
28842 delete arg1;
28843
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 resultobj = SWIG_Py_Void();
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28855 PyObject *resultobj = 0;
28856 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28857 int result;
28858 void *argp1 = 0 ;
28859 int res1 = 0 ;
28860 PyObject *swig_obj[1] ;
28861
28862 if (!args) SWIG_fail;
28863 swig_obj[0] = args;
28864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28865 if (!SWIG_IsOK(res1)) {
28866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28867 }
28868 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 result = (int)(arg1)->Run();
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 resultobj = SWIG_From_int(static_cast< int >(result));
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj = 0;
28884 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28885 int arg2 = (int) 0 ;
28886 void *argp1 = 0 ;
28887 int res1 = 0 ;
28888 int val2 ;
28889 int ecode2 = 0 ;
28890 PyObject * obj0 = 0 ;
28891 PyObject * obj1 = 0 ;
28892 char * kwnames[] = {
28893 (char *) "self",(char *) "rc", NULL
28894 };
28895
28896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28898 if (!SWIG_IsOK(res1)) {
28899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28900 }
28901 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28902 if (obj1) {
28903 ecode2 = SWIG_AsVal_int(obj1, &val2);
28904 if (!SWIG_IsOK(ecode2)) {
28905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28906 }
28907 arg2 = static_cast< int >(val2);
28908 }
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 (arg1)->Exit(arg2);
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 resultobj = SWIG_Py_Void();
28916 return resultobj;
28917 fail:
28918 return NULL;
28919 }
28920
28921
28922 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28923 PyObject *resultobj = 0;
28924 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28925 bool result;
28926 void *argp1 = 0 ;
28927 int res1 = 0 ;
28928 PyObject *swig_obj[1] ;
28929
28930 if (!args) SWIG_fail;
28931 swig_obj[0] = args;
28932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28933 if (!SWIG_IsOK(res1)) {
28934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28935 }
28936 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28937 {
28938 PyThreadState* __tstate = wxPyBeginAllowThreads();
28939 result = (bool)((wxEventLoop const *)arg1)->Pending();
28940 wxPyEndAllowThreads(__tstate);
28941 if (PyErr_Occurred()) SWIG_fail;
28942 }
28943 {
28944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28945 }
28946 return resultobj;
28947 fail:
28948 return NULL;
28949 }
28950
28951
28952 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28953 PyObject *resultobj = 0;
28954 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28955 bool result;
28956 void *argp1 = 0 ;
28957 int res1 = 0 ;
28958 PyObject *swig_obj[1] ;
28959
28960 if (!args) SWIG_fail;
28961 swig_obj[0] = args;
28962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28963 if (!SWIG_IsOK(res1)) {
28964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28965 }
28966 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28967 {
28968 PyThreadState* __tstate = wxPyBeginAllowThreads();
28969 result = (bool)(arg1)->Dispatch();
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 {
28974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28975 }
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983 PyObject *resultobj = 0;
28984 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28985 bool result;
28986 void *argp1 = 0 ;
28987 int res1 = 0 ;
28988 PyObject *swig_obj[1] ;
28989
28990 if (!args) SWIG_fail;
28991 swig_obj[0] = args;
28992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28993 if (!SWIG_IsOK(res1)) {
28994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28995 }
28996 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29000 wxPyEndAllowThreads(__tstate);
29001 if (PyErr_Occurred()) SWIG_fail;
29002 }
29003 {
29004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29005 }
29006 return resultobj;
29007 fail:
29008 return NULL;
29009 }
29010
29011
29012 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29013 PyObject *resultobj = 0;
29014 wxEventLoop *result = 0 ;
29015
29016 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 result = (wxEventLoop *)wxEventLoop::GetActive();
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj = 0;
29032 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29033 void *argp1 = 0 ;
29034 int res1 = 0 ;
29035 PyObject * obj0 = 0 ;
29036 char * kwnames[] = {
29037 (char *) "loop", NULL
29038 };
29039
29040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29042 if (!SWIG_IsOK(res1)) {
29043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29044 }
29045 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29046 {
29047 PyThreadState* __tstate = wxPyBeginAllowThreads();
29048 wxEventLoop::SetActive(arg1);
29049 wxPyEndAllowThreads(__tstate);
29050 if (PyErr_Occurred()) SWIG_fail;
29051 }
29052 resultobj = SWIG_Py_Void();
29053 return resultobj;
29054 fail:
29055 return NULL;
29056 }
29057
29058
29059 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29060 PyObject *obj;
29061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29062 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29063 return SWIG_Py_Void();
29064 }
29065
29066 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29067 return SWIG_Python_InitShadowInstance(args);
29068 }
29069
29070 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj = 0;
29072 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29073 wxEventLoopActivator *result = 0 ;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 PyObject * obj0 = 0 ;
29077 char * kwnames[] = {
29078 (char *) "evtLoop", NULL
29079 };
29080
29081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29083 if (!SWIG_IsOK(res1)) {
29084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29085 }
29086 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29087 {
29088 PyThreadState* __tstate = wxPyBeginAllowThreads();
29089 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29090 wxPyEndAllowThreads(__tstate);
29091 if (PyErr_Occurred()) SWIG_fail;
29092 }
29093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29101 PyObject *resultobj = 0;
29102 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29103 void *argp1 = 0 ;
29104 int res1 = 0 ;
29105 PyObject *swig_obj[1] ;
29106
29107 if (!args) SWIG_fail;
29108 swig_obj[0] = args;
29109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29110 if (!SWIG_IsOK(res1)) {
29111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29112 }
29113 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29114 {
29115 PyThreadState* __tstate = wxPyBeginAllowThreads();
29116 delete arg1;
29117
29118 wxPyEndAllowThreads(__tstate);
29119 if (PyErr_Occurred()) SWIG_fail;
29120 }
29121 resultobj = SWIG_Py_Void();
29122 return resultobj;
29123 fail:
29124 return NULL;
29125 }
29126
29127
29128 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29129 PyObject *obj;
29130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29131 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29132 return SWIG_Py_Void();
29133 }
29134
29135 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 return SWIG_Python_InitShadowInstance(args);
29137 }
29138
29139 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29140 PyObject *resultobj = 0;
29141 int arg1 = (int) 0 ;
29142 int arg2 = (int) 0 ;
29143 int arg3 = (int) 0 ;
29144 wxAcceleratorEntry *result = 0 ;
29145 int val1 ;
29146 int ecode1 = 0 ;
29147 int val2 ;
29148 int ecode2 = 0 ;
29149 int val3 ;
29150 int ecode3 = 0 ;
29151 PyObject * obj0 = 0 ;
29152 PyObject * obj1 = 0 ;
29153 PyObject * obj2 = 0 ;
29154 char * kwnames[] = {
29155 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29156 };
29157
29158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29159 if (obj0) {
29160 ecode1 = SWIG_AsVal_int(obj0, &val1);
29161 if (!SWIG_IsOK(ecode1)) {
29162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29163 }
29164 arg1 = static_cast< int >(val1);
29165 }
29166 if (obj1) {
29167 ecode2 = SWIG_AsVal_int(obj1, &val2);
29168 if (!SWIG_IsOK(ecode2)) {
29169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29170 }
29171 arg2 = static_cast< int >(val2);
29172 }
29173 if (obj2) {
29174 ecode3 = SWIG_AsVal_int(obj2, &val3);
29175 if (!SWIG_IsOK(ecode3)) {
29176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29177 }
29178 arg3 = static_cast< int >(val3);
29179 }
29180 {
29181 PyThreadState* __tstate = wxPyBeginAllowThreads();
29182 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29194 PyObject *resultobj = 0;
29195 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29196 void *argp1 = 0 ;
29197 int res1 = 0 ;
29198 PyObject *swig_obj[1] ;
29199
29200 if (!args) SWIG_fail;
29201 swig_obj[0] = args;
29202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29203 if (!SWIG_IsOK(res1)) {
29204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29205 }
29206 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29207 {
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 delete arg1;
29210
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 resultobj = SWIG_Py_Void();
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29222 PyObject *resultobj = 0;
29223 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29224 int arg2 ;
29225 int arg3 ;
29226 int arg4 ;
29227 void *argp1 = 0 ;
29228 int res1 = 0 ;
29229 int val2 ;
29230 int ecode2 = 0 ;
29231 int val3 ;
29232 int ecode3 = 0 ;
29233 int val4 ;
29234 int ecode4 = 0 ;
29235 PyObject * obj0 = 0 ;
29236 PyObject * obj1 = 0 ;
29237 PyObject * obj2 = 0 ;
29238 PyObject * obj3 = 0 ;
29239 char * kwnames[] = {
29240 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29241 };
29242
29243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29245 if (!SWIG_IsOK(res1)) {
29246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29247 }
29248 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29249 ecode2 = SWIG_AsVal_int(obj1, &val2);
29250 if (!SWIG_IsOK(ecode2)) {
29251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29252 }
29253 arg2 = static_cast< int >(val2);
29254 ecode3 = SWIG_AsVal_int(obj2, &val3);
29255 if (!SWIG_IsOK(ecode3)) {
29256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29257 }
29258 arg3 = static_cast< int >(val3);
29259 ecode4 = SWIG_AsVal_int(obj3, &val4);
29260 if (!SWIG_IsOK(ecode4)) {
29261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29262 }
29263 arg4 = static_cast< int >(val4);
29264 {
29265 PyThreadState* __tstate = wxPyBeginAllowThreads();
29266 (arg1)->Set(arg2,arg3,arg4);
29267 wxPyEndAllowThreads(__tstate);
29268 if (PyErr_Occurred()) SWIG_fail;
29269 }
29270 resultobj = SWIG_Py_Void();
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29278 PyObject *resultobj = 0;
29279 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29280 int result;
29281 void *argp1 = 0 ;
29282 int res1 = 0 ;
29283 PyObject *swig_obj[1] ;
29284
29285 if (!args) SWIG_fail;
29286 swig_obj[0] = args;
29287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29288 if (!SWIG_IsOK(res1)) {
29289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29290 }
29291 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29292 {
29293 PyThreadState* __tstate = wxPyBeginAllowThreads();
29294 result = (int)(arg1)->GetFlags();
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 resultobj = SWIG_From_int(static_cast< int >(result));
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29306 PyObject *resultobj = 0;
29307 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29308 int result;
29309 void *argp1 = 0 ;
29310 int res1 = 0 ;
29311 PyObject *swig_obj[1] ;
29312
29313 if (!args) SWIG_fail;
29314 swig_obj[0] = args;
29315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29316 if (!SWIG_IsOK(res1)) {
29317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29318 }
29319 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 result = (int)(arg1)->GetKeyCode();
29323 wxPyEndAllowThreads(__tstate);
29324 if (PyErr_Occurred()) SWIG_fail;
29325 }
29326 resultobj = SWIG_From_int(static_cast< int >(result));
29327 return resultobj;
29328 fail:
29329 return NULL;
29330 }
29331
29332
29333 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29334 PyObject *resultobj = 0;
29335 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29336 int result;
29337 void *argp1 = 0 ;
29338 int res1 = 0 ;
29339 PyObject *swig_obj[1] ;
29340
29341 if (!args) SWIG_fail;
29342 swig_obj[0] = args;
29343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29344 if (!SWIG_IsOK(res1)) {
29345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29346 }
29347 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 result = (int)(arg1)->GetCommand();
29351 wxPyEndAllowThreads(__tstate);
29352 if (PyErr_Occurred()) SWIG_fail;
29353 }
29354 resultobj = SWIG_From_int(static_cast< int >(result));
29355 return resultobj;
29356 fail:
29357 return NULL;
29358 }
29359
29360
29361 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29362 PyObject *obj;
29363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29364 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29365 return SWIG_Py_Void();
29366 }
29367
29368 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29369 return SWIG_Python_InitShadowInstance(args);
29370 }
29371
29372 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29373 PyObject *resultobj = 0;
29374 int arg1 ;
29375 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29376 wxAcceleratorTable *result = 0 ;
29377 PyObject * obj0 = 0 ;
29378 char * kwnames[] = {
29379 (char *) "n", NULL
29380 };
29381
29382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29383 {
29384 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29385 if (arg2) arg1 = PyList_Size(obj0);
29386 else arg1 = 0;
29387 }
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29391 wxPyEndAllowThreads(__tstate);
29392 if (PyErr_Occurred()) SWIG_fail;
29393 }
29394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29395 return resultobj;
29396 fail:
29397 return NULL;
29398 }
29399
29400
29401 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29402 PyObject *resultobj = 0;
29403 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 PyObject *swig_obj[1] ;
29407
29408 if (!args) SWIG_fail;
29409 swig_obj[0] = args;
29410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29413 }
29414 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 delete arg1;
29418
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 resultobj = SWIG_Py_Void();
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29430 PyObject *resultobj = 0;
29431 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29432 bool result;
29433 void *argp1 = 0 ;
29434 int res1 = 0 ;
29435 PyObject *swig_obj[1] ;
29436
29437 if (!args) SWIG_fail;
29438 swig_obj[0] = args;
29439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29440 if (!SWIG_IsOK(res1)) {
29441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29442 }
29443 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29447 wxPyEndAllowThreads(__tstate);
29448 if (PyErr_Occurred()) SWIG_fail;
29449 }
29450 {
29451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29452 }
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29460 PyObject *obj;
29461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29462 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29463 return SWIG_Py_Void();
29464 }
29465
29466 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29467 return SWIG_Python_InitShadowInstance(args);
29468 }
29469
29470 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29471 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29472 return 1;
29473 }
29474
29475
29476 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29477 PyObject *pyobj = 0;
29478
29479 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29480 return pyobj;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29485 PyObject *resultobj = 0;
29486 wxString *arg1 = 0 ;
29487 wxAcceleratorEntry *result = 0 ;
29488 bool temp1 = false ;
29489 PyObject * obj0 = 0 ;
29490 char * kwnames[] = {
29491 (char *) "label", NULL
29492 };
29493
29494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29495 {
29496 arg1 = wxString_in_helper(obj0);
29497 if (arg1 == NULL) SWIG_fail;
29498 temp1 = true;
29499 }
29500 {
29501 PyThreadState* __tstate = wxPyBeginAllowThreads();
29502 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29507 {
29508 if (temp1)
29509 delete arg1;
29510 }
29511 return resultobj;
29512 fail:
29513 {
29514 if (temp1)
29515 delete arg1;
29516 }
29517 return NULL;
29518 }
29519
29520
29521 SWIGINTERN int PanelNameStr_set(PyObject *) {
29522 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29523 return 1;
29524 }
29525
29526
29527 SWIGINTERN PyObject *PanelNameStr_get(void) {
29528 PyObject *pyobj = 0;
29529
29530 {
29531 #if wxUSE_UNICODE
29532 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29533 #else
29534 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29535 #endif
29536 }
29537 return pyobj;
29538 }
29539
29540
29541 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29542 PyObject *resultobj = 0;
29543 wxVisualAttributes *result = 0 ;
29544
29545 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 result = (wxVisualAttributes *)new_wxVisualAttributes();
29549 wxPyEndAllowThreads(__tstate);
29550 if (PyErr_Occurred()) SWIG_fail;
29551 }
29552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29560 PyObject *resultobj = 0;
29561 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29562 void *argp1 = 0 ;
29563 int res1 = 0 ;
29564 PyObject *swig_obj[1] ;
29565
29566 if (!args) SWIG_fail;
29567 swig_obj[0] = args;
29568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29569 if (!SWIG_IsOK(res1)) {
29570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29571 }
29572 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 delete_wxVisualAttributes(arg1);
29576
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 resultobj = SWIG_Py_Void();
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29588 PyObject *resultobj = 0;
29589 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29590 wxFont *arg2 = (wxFont *) 0 ;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 void *argp2 = 0 ;
29594 int res2 = 0 ;
29595 PyObject *swig_obj[2] ;
29596
29597 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29599 if (!SWIG_IsOK(res1)) {
29600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29601 }
29602 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29603 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29604 if (!SWIG_IsOK(res2)) {
29605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29606 }
29607 arg2 = reinterpret_cast< wxFont * >(argp2);
29608 if (arg1) (arg1)->font = *arg2;
29609
29610 resultobj = SWIG_Py_Void();
29611 return resultobj;
29612 fail:
29613 return NULL;
29614 }
29615
29616
29617 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29618 PyObject *resultobj = 0;
29619 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29620 wxFont *result = 0 ;
29621 void *argp1 = 0 ;
29622 int res1 = 0 ;
29623 PyObject *swig_obj[1] ;
29624
29625 if (!args) SWIG_fail;
29626 swig_obj[0] = args;
29627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29628 if (!SWIG_IsOK(res1)) {
29629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29630 }
29631 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29632 result = (wxFont *)& ((arg1)->font);
29633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29634 return resultobj;
29635 fail:
29636 return NULL;
29637 }
29638
29639
29640 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29641 PyObject *resultobj = 0;
29642 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29643 wxColour *arg2 = (wxColour *) 0 ;
29644 void *argp1 = 0 ;
29645 int res1 = 0 ;
29646 void *argp2 = 0 ;
29647 int res2 = 0 ;
29648 PyObject *swig_obj[2] ;
29649
29650 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29652 if (!SWIG_IsOK(res1)) {
29653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29654 }
29655 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29656 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29657 if (!SWIG_IsOK(res2)) {
29658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29659 }
29660 arg2 = reinterpret_cast< wxColour * >(argp2);
29661 if (arg1) (arg1)->colFg = *arg2;
29662
29663 resultobj = SWIG_Py_Void();
29664 return resultobj;
29665 fail:
29666 return NULL;
29667 }
29668
29669
29670 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29671 PyObject *resultobj = 0;
29672 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29673 wxColour *result = 0 ;
29674 void *argp1 = 0 ;
29675 int res1 = 0 ;
29676 PyObject *swig_obj[1] ;
29677
29678 if (!args) SWIG_fail;
29679 swig_obj[0] = args;
29680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29681 if (!SWIG_IsOK(res1)) {
29682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29683 }
29684 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29685 result = (wxColour *)& ((arg1)->colFg);
29686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29687 return resultobj;
29688 fail:
29689 return NULL;
29690 }
29691
29692
29693 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29694 PyObject *resultobj = 0;
29695 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29696 wxColour *arg2 = (wxColour *) 0 ;
29697 void *argp1 = 0 ;
29698 int res1 = 0 ;
29699 void *argp2 = 0 ;
29700 int res2 = 0 ;
29701 PyObject *swig_obj[2] ;
29702
29703 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29705 if (!SWIG_IsOK(res1)) {
29706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29707 }
29708 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29709 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29710 if (!SWIG_IsOK(res2)) {
29711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29712 }
29713 arg2 = reinterpret_cast< wxColour * >(argp2);
29714 if (arg1) (arg1)->colBg = *arg2;
29715
29716 resultobj = SWIG_Py_Void();
29717 return resultobj;
29718 fail:
29719 return NULL;
29720 }
29721
29722
29723 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29724 PyObject *resultobj = 0;
29725 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29726 wxColour *result = 0 ;
29727 void *argp1 = 0 ;
29728 int res1 = 0 ;
29729 PyObject *swig_obj[1] ;
29730
29731 if (!args) SWIG_fail;
29732 swig_obj[0] = args;
29733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29734 if (!SWIG_IsOK(res1)) {
29735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29736 }
29737 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29738 result = (wxColour *)& ((arg1)->colBg);
29739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29747 PyObject *obj;
29748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29749 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29750 return SWIG_Py_Void();
29751 }
29752
29753 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29754 return SWIG_Python_InitShadowInstance(args);
29755 }
29756
29757 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj = 0;
29759 wxWindow *arg1 = (wxWindow *) 0 ;
29760 int arg2 = (int) (int)-1 ;
29761 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29762 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29763 wxSize const &arg4_defvalue = wxDefaultSize ;
29764 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29765 long arg5 = (long) 0 ;
29766 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29767 wxString *arg6 = (wxString *) &arg6_defvalue ;
29768 wxWindow *result = 0 ;
29769 void *argp1 = 0 ;
29770 int res1 = 0 ;
29771 int val2 ;
29772 int ecode2 = 0 ;
29773 wxPoint temp3 ;
29774 wxSize temp4 ;
29775 long val5 ;
29776 int ecode5 = 0 ;
29777 bool temp6 = false ;
29778 PyObject * obj0 = 0 ;
29779 PyObject * obj1 = 0 ;
29780 PyObject * obj2 = 0 ;
29781 PyObject * obj3 = 0 ;
29782 PyObject * obj4 = 0 ;
29783 PyObject * obj5 = 0 ;
29784 char * kwnames[] = {
29785 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29786 };
29787
29788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29790 if (!SWIG_IsOK(res1)) {
29791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29792 }
29793 arg1 = reinterpret_cast< wxWindow * >(argp1);
29794 if (obj1) {
29795 ecode2 = SWIG_AsVal_int(obj1, &val2);
29796 if (!SWIG_IsOK(ecode2)) {
29797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29798 }
29799 arg2 = static_cast< int >(val2);
29800 }
29801 if (obj2) {
29802 {
29803 arg3 = &temp3;
29804 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29805 }
29806 }
29807 if (obj3) {
29808 {
29809 arg4 = &temp4;
29810 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29811 }
29812 }
29813 if (obj4) {
29814 ecode5 = SWIG_AsVal_long(obj4, &val5);
29815 if (!SWIG_IsOK(ecode5)) {
29816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29817 }
29818 arg5 = static_cast< long >(val5);
29819 }
29820 if (obj5) {
29821 {
29822 arg6 = wxString_in_helper(obj5);
29823 if (arg6 == NULL) SWIG_fail;
29824 temp6 = true;
29825 }
29826 }
29827 {
29828 if (!wxPyCheckForApp()) SWIG_fail;
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29831 wxPyEndAllowThreads(__tstate);
29832 if (PyErr_Occurred()) SWIG_fail;
29833 }
29834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29835 {
29836 if (temp6)
29837 delete arg6;
29838 }
29839 return resultobj;
29840 fail:
29841 {
29842 if (temp6)
29843 delete arg6;
29844 }
29845 return NULL;
29846 }
29847
29848
29849 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29850 PyObject *resultobj = 0;
29851 wxWindow *result = 0 ;
29852
29853 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29854 {
29855 if (!wxPyCheckForApp()) SWIG_fail;
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 result = (wxWindow *)new wxWindow();
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj = 0;
29870 wxWindow *arg1 = (wxWindow *) 0 ;
29871 wxWindow *arg2 = (wxWindow *) 0 ;
29872 int arg3 = (int) (int)-1 ;
29873 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29874 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29875 wxSize const &arg5_defvalue = wxDefaultSize ;
29876 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29877 long arg6 = (long) 0 ;
29878 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29879 wxString *arg7 = (wxString *) &arg7_defvalue ;
29880 bool result;
29881 void *argp1 = 0 ;
29882 int res1 = 0 ;
29883 void *argp2 = 0 ;
29884 int res2 = 0 ;
29885 int val3 ;
29886 int ecode3 = 0 ;
29887 wxPoint temp4 ;
29888 wxSize temp5 ;
29889 long val6 ;
29890 int ecode6 = 0 ;
29891 bool temp7 = false ;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 PyObject * obj2 = 0 ;
29895 PyObject * obj3 = 0 ;
29896 PyObject * obj4 = 0 ;
29897 PyObject * obj5 = 0 ;
29898 PyObject * obj6 = 0 ;
29899 char * kwnames[] = {
29900 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29901 };
29902
29903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29905 if (!SWIG_IsOK(res1)) {
29906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29907 }
29908 arg1 = reinterpret_cast< wxWindow * >(argp1);
29909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29910 if (!SWIG_IsOK(res2)) {
29911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29912 }
29913 arg2 = reinterpret_cast< wxWindow * >(argp2);
29914 if (obj2) {
29915 ecode3 = SWIG_AsVal_int(obj2, &val3);
29916 if (!SWIG_IsOK(ecode3)) {
29917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29918 }
29919 arg3 = static_cast< int >(val3);
29920 }
29921 if (obj3) {
29922 {
29923 arg4 = &temp4;
29924 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29925 }
29926 }
29927 if (obj4) {
29928 {
29929 arg5 = &temp5;
29930 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29931 }
29932 }
29933 if (obj5) {
29934 ecode6 = SWIG_AsVal_long(obj5, &val6);
29935 if (!SWIG_IsOK(ecode6)) {
29936 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29937 }
29938 arg6 = static_cast< long >(val6);
29939 }
29940 if (obj6) {
29941 {
29942 arg7 = wxString_in_helper(obj6);
29943 if (arg7 == NULL) SWIG_fail;
29944 temp7 = true;
29945 }
29946 }
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29950 wxPyEndAllowThreads(__tstate);
29951 if (PyErr_Occurred()) SWIG_fail;
29952 }
29953 {
29954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29955 }
29956 {
29957 if (temp7)
29958 delete arg7;
29959 }
29960 return resultobj;
29961 fail:
29962 {
29963 if (temp7)
29964 delete arg7;
29965 }
29966 return NULL;
29967 }
29968
29969
29970 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29971 PyObject *resultobj = 0;
29972 wxWindow *arg1 = (wxWindow *) 0 ;
29973 bool arg2 = (bool) false ;
29974 bool result;
29975 void *argp1 = 0 ;
29976 int res1 = 0 ;
29977 bool val2 ;
29978 int ecode2 = 0 ;
29979 PyObject * obj0 = 0 ;
29980 PyObject * obj1 = 0 ;
29981 char * kwnames[] = {
29982 (char *) "self",(char *) "force", NULL
29983 };
29984
29985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29987 if (!SWIG_IsOK(res1)) {
29988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29989 }
29990 arg1 = reinterpret_cast< wxWindow * >(argp1);
29991 if (obj1) {
29992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29993 if (!SWIG_IsOK(ecode2)) {
29994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29995 }
29996 arg2 = static_cast< bool >(val2);
29997 }
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 result = (bool)(arg1)->Close(arg2);
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 {
30005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30006 }
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30014 PyObject *resultobj = 0;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 bool result;
30017 void *argp1 = 0 ;
30018 int res1 = 0 ;
30019 PyObject *swig_obj[1] ;
30020
30021 if (!args) SWIG_fail;
30022 swig_obj[0] = args;
30023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30024 if (!SWIG_IsOK(res1)) {
30025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30026 }
30027 arg1 = reinterpret_cast< wxWindow * >(argp1);
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (bool)(arg1)->Destroy();
30031 wxPyEndAllowThreads(__tstate);
30032 if (PyErr_Occurred()) SWIG_fail;
30033 }
30034 {
30035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30036 }
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30044 PyObject *resultobj = 0;
30045 wxWindow *arg1 = (wxWindow *) 0 ;
30046 bool result;
30047 void *argp1 = 0 ;
30048 int res1 = 0 ;
30049 PyObject *swig_obj[1] ;
30050
30051 if (!args) SWIG_fail;
30052 swig_obj[0] = args;
30053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30056 }
30057 arg1 = reinterpret_cast< wxWindow * >(argp1);
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 result = (bool)(arg1)->DestroyChildren();
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 {
30065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30066 }
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30074 PyObject *resultobj = 0;
30075 wxWindow *arg1 = (wxWindow *) 0 ;
30076 bool result;
30077 void *argp1 = 0 ;
30078 int res1 = 0 ;
30079 PyObject *swig_obj[1] ;
30080
30081 if (!args) SWIG_fail;
30082 swig_obj[0] = args;
30083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30084 if (!SWIG_IsOK(res1)) {
30085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30086 }
30087 arg1 = reinterpret_cast< wxWindow * >(argp1);
30088 {
30089 PyThreadState* __tstate = wxPyBeginAllowThreads();
30090 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30091 wxPyEndAllowThreads(__tstate);
30092 if (PyErr_Occurred()) SWIG_fail;
30093 }
30094 {
30095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30096 }
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30104 PyObject *resultobj = 0;
30105 wxWindow *arg1 = (wxWindow *) 0 ;
30106 wxString *arg2 = 0 ;
30107 void *argp1 = 0 ;
30108 int res1 = 0 ;
30109 bool temp2 = false ;
30110 PyObject * obj0 = 0 ;
30111 PyObject * obj1 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "self",(char *) "label", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30120 }
30121 arg1 = reinterpret_cast< wxWindow * >(argp1);
30122 {
30123 arg2 = wxString_in_helper(obj1);
30124 if (arg2 == NULL) SWIG_fail;
30125 temp2 = true;
30126 }
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 (arg1)->SetLabel((wxString const &)*arg2);
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 resultobj = SWIG_Py_Void();
30134 {
30135 if (temp2)
30136 delete arg2;
30137 }
30138 return resultobj;
30139 fail:
30140 {
30141 if (temp2)
30142 delete arg2;
30143 }
30144 return NULL;
30145 }
30146
30147
30148 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30149 PyObject *resultobj = 0;
30150 wxWindow *arg1 = (wxWindow *) 0 ;
30151 wxString result;
30152 void *argp1 = 0 ;
30153 int res1 = 0 ;
30154 PyObject *swig_obj[1] ;
30155
30156 if (!args) SWIG_fail;
30157 swig_obj[0] = args;
30158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30159 if (!SWIG_IsOK(res1)) {
30160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30161 }
30162 arg1 = reinterpret_cast< wxWindow * >(argp1);
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 result = ((wxWindow const *)arg1)->GetLabel();
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 {
30170 #if wxUSE_UNICODE
30171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30172 #else
30173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30174 #endif
30175 }
30176 return resultobj;
30177 fail:
30178 return NULL;
30179 }
30180
30181
30182 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30183 PyObject *resultobj = 0;
30184 wxWindow *arg1 = (wxWindow *) 0 ;
30185 wxString *arg2 = 0 ;
30186 void *argp1 = 0 ;
30187 int res1 = 0 ;
30188 bool temp2 = false ;
30189 PyObject * obj0 = 0 ;
30190 PyObject * obj1 = 0 ;
30191 char * kwnames[] = {
30192 (char *) "self",(char *) "name", NULL
30193 };
30194
30195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30197 if (!SWIG_IsOK(res1)) {
30198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30199 }
30200 arg1 = reinterpret_cast< wxWindow * >(argp1);
30201 {
30202 arg2 = wxString_in_helper(obj1);
30203 if (arg2 == NULL) SWIG_fail;
30204 temp2 = true;
30205 }
30206 {
30207 PyThreadState* __tstate = wxPyBeginAllowThreads();
30208 (arg1)->SetName((wxString const &)*arg2);
30209 wxPyEndAllowThreads(__tstate);
30210 if (PyErr_Occurred()) SWIG_fail;
30211 }
30212 resultobj = SWIG_Py_Void();
30213 {
30214 if (temp2)
30215 delete arg2;
30216 }
30217 return resultobj;
30218 fail:
30219 {
30220 if (temp2)
30221 delete arg2;
30222 }
30223 return NULL;
30224 }
30225
30226
30227 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30228 PyObject *resultobj = 0;
30229 wxWindow *arg1 = (wxWindow *) 0 ;
30230 wxString result;
30231 void *argp1 = 0 ;
30232 int res1 = 0 ;
30233 PyObject *swig_obj[1] ;
30234
30235 if (!args) SWIG_fail;
30236 swig_obj[0] = args;
30237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30238 if (!SWIG_IsOK(res1)) {
30239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30240 }
30241 arg1 = reinterpret_cast< wxWindow * >(argp1);
30242 {
30243 PyThreadState* __tstate = wxPyBeginAllowThreads();
30244 result = ((wxWindow const *)arg1)->GetName();
30245 wxPyEndAllowThreads(__tstate);
30246 if (PyErr_Occurred()) SWIG_fail;
30247 }
30248 {
30249 #if wxUSE_UNICODE
30250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30251 #else
30252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30253 #endif
30254 }
30255 return resultobj;
30256 fail:
30257 return NULL;
30258 }
30259
30260
30261 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30262 PyObject *resultobj = 0;
30263 wxWindow *arg1 = (wxWindow *) 0 ;
30264 wxWindowVariant arg2 ;
30265 void *argp1 = 0 ;
30266 int res1 = 0 ;
30267 int val2 ;
30268 int ecode2 = 0 ;
30269 PyObject * obj0 = 0 ;
30270 PyObject * obj1 = 0 ;
30271 char * kwnames[] = {
30272 (char *) "self",(char *) "variant", NULL
30273 };
30274
30275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30277 if (!SWIG_IsOK(res1)) {
30278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30279 }
30280 arg1 = reinterpret_cast< wxWindow * >(argp1);
30281 ecode2 = SWIG_AsVal_int(obj1, &val2);
30282 if (!SWIG_IsOK(ecode2)) {
30283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30284 }
30285 arg2 = static_cast< wxWindowVariant >(val2);
30286 {
30287 PyThreadState* __tstate = wxPyBeginAllowThreads();
30288 (arg1)->SetWindowVariant(arg2);
30289 wxPyEndAllowThreads(__tstate);
30290 if (PyErr_Occurred()) SWIG_fail;
30291 }
30292 resultobj = SWIG_Py_Void();
30293 return resultobj;
30294 fail:
30295 return NULL;
30296 }
30297
30298
30299 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30300 PyObject *resultobj = 0;
30301 wxWindow *arg1 = (wxWindow *) 0 ;
30302 wxWindowVariant result;
30303 void *argp1 = 0 ;
30304 int res1 = 0 ;
30305 PyObject *swig_obj[1] ;
30306
30307 if (!args) SWIG_fail;
30308 swig_obj[0] = args;
30309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30310 if (!SWIG_IsOK(res1)) {
30311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30312 }
30313 arg1 = reinterpret_cast< wxWindow * >(argp1);
30314 {
30315 PyThreadState* __tstate = wxPyBeginAllowThreads();
30316 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30317 wxPyEndAllowThreads(__tstate);
30318 if (PyErr_Occurred()) SWIG_fail;
30319 }
30320 resultobj = SWIG_From_int(static_cast< int >(result));
30321 return resultobj;
30322 fail:
30323 return NULL;
30324 }
30325
30326
30327 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30328 PyObject *resultobj = 0;
30329 wxWindow *arg1 = (wxWindow *) 0 ;
30330 int arg2 ;
30331 void *argp1 = 0 ;
30332 int res1 = 0 ;
30333 int val2 ;
30334 int ecode2 = 0 ;
30335 PyObject * obj0 = 0 ;
30336 PyObject * obj1 = 0 ;
30337 char * kwnames[] = {
30338 (char *) "self",(char *) "winid", NULL
30339 };
30340
30341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30343 if (!SWIG_IsOK(res1)) {
30344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30345 }
30346 arg1 = reinterpret_cast< wxWindow * >(argp1);
30347 ecode2 = SWIG_AsVal_int(obj1, &val2);
30348 if (!SWIG_IsOK(ecode2)) {
30349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30350 }
30351 arg2 = static_cast< int >(val2);
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 (arg1)->SetId(arg2);
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_Py_Void();
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30366 PyObject *resultobj = 0;
30367 wxWindow *arg1 = (wxWindow *) 0 ;
30368 int result;
30369 void *argp1 = 0 ;
30370 int res1 = 0 ;
30371 PyObject *swig_obj[1] ;
30372
30373 if (!args) SWIG_fail;
30374 swig_obj[0] = args;
30375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30376 if (!SWIG_IsOK(res1)) {
30377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30378 }
30379 arg1 = reinterpret_cast< wxWindow * >(argp1);
30380 {
30381 PyThreadState* __tstate = wxPyBeginAllowThreads();
30382 result = (int)((wxWindow const *)arg1)->GetId();
30383 wxPyEndAllowThreads(__tstate);
30384 if (PyErr_Occurred()) SWIG_fail;
30385 }
30386 resultobj = SWIG_From_int(static_cast< int >(result));
30387 return resultobj;
30388 fail:
30389 return NULL;
30390 }
30391
30392
30393 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30394 PyObject *resultobj = 0;
30395 int result;
30396
30397 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (int)wxWindow::NewControlId();
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 resultobj = SWIG_From_int(static_cast< int >(result));
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30412 PyObject *resultobj = 0;
30413 int arg1 ;
30414 int result;
30415 int val1 ;
30416 int ecode1 = 0 ;
30417 PyObject * obj0 = 0 ;
30418 char * kwnames[] = {
30419 (char *) "winid", NULL
30420 };
30421
30422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30423 ecode1 = SWIG_AsVal_int(obj0, &val1);
30424 if (!SWIG_IsOK(ecode1)) {
30425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30426 }
30427 arg1 = static_cast< int >(val1);
30428 {
30429 PyThreadState* __tstate = wxPyBeginAllowThreads();
30430 result = (int)wxWindow::NextControlId(arg1);
30431 wxPyEndAllowThreads(__tstate);
30432 if (PyErr_Occurred()) SWIG_fail;
30433 }
30434 resultobj = SWIG_From_int(static_cast< int >(result));
30435 return resultobj;
30436 fail:
30437 return NULL;
30438 }
30439
30440
30441 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30442 PyObject *resultobj = 0;
30443 int arg1 ;
30444 int result;
30445 int val1 ;
30446 int ecode1 = 0 ;
30447 PyObject * obj0 = 0 ;
30448 char * kwnames[] = {
30449 (char *) "winid", NULL
30450 };
30451
30452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30453 ecode1 = SWIG_AsVal_int(obj0, &val1);
30454 if (!SWIG_IsOK(ecode1)) {
30455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30456 }
30457 arg1 = static_cast< int >(val1);
30458 {
30459 PyThreadState* __tstate = wxPyBeginAllowThreads();
30460 result = (int)wxWindow::PrevControlId(arg1);
30461 wxPyEndAllowThreads(__tstate);
30462 if (PyErr_Occurred()) SWIG_fail;
30463 }
30464 resultobj = SWIG_From_int(static_cast< int >(result));
30465 return resultobj;
30466 fail:
30467 return NULL;
30468 }
30469
30470
30471 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30472 PyObject *resultobj = 0;
30473 wxWindow *arg1 = (wxWindow *) 0 ;
30474 wxSize *arg2 = 0 ;
30475 void *argp1 = 0 ;
30476 int res1 = 0 ;
30477 wxSize temp2 ;
30478 PyObject * obj0 = 0 ;
30479 PyObject * obj1 = 0 ;
30480 char * kwnames[] = {
30481 (char *) "self",(char *) "size", NULL
30482 };
30483
30484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30486 if (!SWIG_IsOK(res1)) {
30487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30488 }
30489 arg1 = reinterpret_cast< wxWindow * >(argp1);
30490 {
30491 arg2 = &temp2;
30492 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30493 }
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 (arg1)->SetSize((wxSize const &)*arg2);
30497 wxPyEndAllowThreads(__tstate);
30498 if (PyErr_Occurred()) SWIG_fail;
30499 }
30500 resultobj = SWIG_Py_Void();
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30508 PyObject *resultobj = 0;
30509 wxWindow *arg1 = (wxWindow *) 0 ;
30510 int arg2 ;
30511 int arg3 ;
30512 int arg4 ;
30513 int arg5 ;
30514 int arg6 = (int) wxSIZE_AUTO ;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 int val2 ;
30518 int ecode2 = 0 ;
30519 int val3 ;
30520 int ecode3 = 0 ;
30521 int val4 ;
30522 int ecode4 = 0 ;
30523 int val5 ;
30524 int ecode5 = 0 ;
30525 int val6 ;
30526 int ecode6 = 0 ;
30527 PyObject * obj0 = 0 ;
30528 PyObject * obj1 = 0 ;
30529 PyObject * obj2 = 0 ;
30530 PyObject * obj3 = 0 ;
30531 PyObject * obj4 = 0 ;
30532 PyObject * obj5 = 0 ;
30533 char * kwnames[] = {
30534 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30535 };
30536
30537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30541 }
30542 arg1 = reinterpret_cast< wxWindow * >(argp1);
30543 ecode2 = SWIG_AsVal_int(obj1, &val2);
30544 if (!SWIG_IsOK(ecode2)) {
30545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30546 }
30547 arg2 = static_cast< int >(val2);
30548 ecode3 = SWIG_AsVal_int(obj2, &val3);
30549 if (!SWIG_IsOK(ecode3)) {
30550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30551 }
30552 arg3 = static_cast< int >(val3);
30553 ecode4 = SWIG_AsVal_int(obj3, &val4);
30554 if (!SWIG_IsOK(ecode4)) {
30555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30556 }
30557 arg4 = static_cast< int >(val4);
30558 ecode5 = SWIG_AsVal_int(obj4, &val5);
30559 if (!SWIG_IsOK(ecode5)) {
30560 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30561 }
30562 arg5 = static_cast< int >(val5);
30563 if (obj5) {
30564 ecode6 = SWIG_AsVal_int(obj5, &val6);
30565 if (!SWIG_IsOK(ecode6)) {
30566 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30567 }
30568 arg6 = static_cast< int >(val6);
30569 }
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 resultobj = SWIG_Py_Void();
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30584 PyObject *resultobj = 0;
30585 wxWindow *arg1 = (wxWindow *) 0 ;
30586 wxRect *arg2 = 0 ;
30587 int arg3 = (int) wxSIZE_AUTO ;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 wxRect temp2 ;
30591 int val3 ;
30592 int ecode3 = 0 ;
30593 PyObject * obj0 = 0 ;
30594 PyObject * obj1 = 0 ;
30595 PyObject * obj2 = 0 ;
30596 char * kwnames[] = {
30597 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30598 };
30599
30600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30602 if (!SWIG_IsOK(res1)) {
30603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30604 }
30605 arg1 = reinterpret_cast< wxWindow * >(argp1);
30606 {
30607 arg2 = &temp2;
30608 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30609 }
30610 if (obj2) {
30611 ecode3 = SWIG_AsVal_int(obj2, &val3);
30612 if (!SWIG_IsOK(ecode3)) {
30613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30614 }
30615 arg3 = static_cast< int >(val3);
30616 }
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 resultobj = SWIG_Py_Void();
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30631 PyObject *resultobj = 0;
30632 wxWindow *arg1 = (wxWindow *) 0 ;
30633 int arg2 ;
30634 int arg3 ;
30635 void *argp1 = 0 ;
30636 int res1 = 0 ;
30637 int val2 ;
30638 int ecode2 = 0 ;
30639 int val3 ;
30640 int ecode3 = 0 ;
30641 PyObject * obj0 = 0 ;
30642 PyObject * obj1 = 0 ;
30643 PyObject * obj2 = 0 ;
30644 char * kwnames[] = {
30645 (char *) "self",(char *) "width",(char *) "height", NULL
30646 };
30647
30648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30650 if (!SWIG_IsOK(res1)) {
30651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30652 }
30653 arg1 = reinterpret_cast< wxWindow * >(argp1);
30654 ecode2 = SWIG_AsVal_int(obj1, &val2);
30655 if (!SWIG_IsOK(ecode2)) {
30656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30657 }
30658 arg2 = static_cast< int >(val2);
30659 ecode3 = SWIG_AsVal_int(obj2, &val3);
30660 if (!SWIG_IsOK(ecode3)) {
30661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30662 }
30663 arg3 = static_cast< int >(val3);
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 (arg1)->SetSize(arg2,arg3);
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_Py_Void();
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 wxPoint *arg2 = 0 ;
30681 int arg3 = (int) wxSIZE_USE_EXISTING ;
30682 void *argp1 = 0 ;
30683 int res1 = 0 ;
30684 wxPoint temp2 ;
30685 int val3 ;
30686 int ecode3 = 0 ;
30687 PyObject * obj0 = 0 ;
30688 PyObject * obj1 = 0 ;
30689 PyObject * obj2 = 0 ;
30690 char * kwnames[] = {
30691 (char *) "self",(char *) "pt",(char *) "flags", NULL
30692 };
30693
30694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30696 if (!SWIG_IsOK(res1)) {
30697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30698 }
30699 arg1 = reinterpret_cast< wxWindow * >(argp1);
30700 {
30701 arg2 = &temp2;
30702 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30703 }
30704 if (obj2) {
30705 ecode3 = SWIG_AsVal_int(obj2, &val3);
30706 if (!SWIG_IsOK(ecode3)) {
30707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30708 }
30709 arg3 = static_cast< int >(val3);
30710 }
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 (arg1)->Move((wxPoint const &)*arg2,arg3);
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_Py_Void();
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30725 PyObject *resultobj = 0;
30726 wxWindow *arg1 = (wxWindow *) 0 ;
30727 int arg2 ;
30728 int arg3 ;
30729 int arg4 = (int) wxSIZE_USE_EXISTING ;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 int val2 ;
30733 int ecode2 = 0 ;
30734 int val3 ;
30735 int ecode3 = 0 ;
30736 int val4 ;
30737 int ecode4 = 0 ;
30738 PyObject * obj0 = 0 ;
30739 PyObject * obj1 = 0 ;
30740 PyObject * obj2 = 0 ;
30741 PyObject * obj3 = 0 ;
30742 char * kwnames[] = {
30743 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30744 };
30745
30746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30748 if (!SWIG_IsOK(res1)) {
30749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30750 }
30751 arg1 = reinterpret_cast< wxWindow * >(argp1);
30752 ecode2 = SWIG_AsVal_int(obj1, &val2);
30753 if (!SWIG_IsOK(ecode2)) {
30754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30755 }
30756 arg2 = static_cast< int >(val2);
30757 ecode3 = SWIG_AsVal_int(obj2, &val3);
30758 if (!SWIG_IsOK(ecode3)) {
30759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30760 }
30761 arg3 = static_cast< int >(val3);
30762 if (obj3) {
30763 ecode4 = SWIG_AsVal_int(obj3, &val4);
30764 if (!SWIG_IsOK(ecode4)) {
30765 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30766 }
30767 arg4 = static_cast< int >(val4);
30768 }
30769 {
30770 PyThreadState* __tstate = wxPyBeginAllowThreads();
30771 (arg1)->Move(arg2,arg3,arg4);
30772 wxPyEndAllowThreads(__tstate);
30773 if (PyErr_Occurred()) SWIG_fail;
30774 }
30775 resultobj = SWIG_Py_Void();
30776 return resultobj;
30777 fail:
30778 return NULL;
30779 }
30780
30781
30782 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30783 PyObject *resultobj = 0;
30784 wxWindow *arg1 = (wxWindow *) 0 ;
30785 wxSize const &arg2_defvalue = wxDefaultSize ;
30786 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30787 void *argp1 = 0 ;
30788 int res1 = 0 ;
30789 wxSize temp2 ;
30790 PyObject * obj0 = 0 ;
30791 PyObject * obj1 = 0 ;
30792 char * kwnames[] = {
30793 (char *) "self",(char *) "size", NULL
30794 };
30795
30796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30798 if (!SWIG_IsOK(res1)) {
30799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30800 }
30801 arg1 = reinterpret_cast< wxWindow * >(argp1);
30802 if (obj1) {
30803 {
30804 arg2 = &temp2;
30805 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30806 }
30807 }
30808 {
30809 PyThreadState* __tstate = wxPyBeginAllowThreads();
30810 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30811 wxPyEndAllowThreads(__tstate);
30812 if (PyErr_Occurred()) SWIG_fail;
30813 }
30814 resultobj = SWIG_Py_Void();
30815 return resultobj;
30816 fail:
30817 return NULL;
30818 }
30819
30820
30821 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30822 PyObject *resultobj = 0;
30823 wxWindow *arg1 = (wxWindow *) 0 ;
30824 void *argp1 = 0 ;
30825 int res1 = 0 ;
30826 PyObject *swig_obj[1] ;
30827
30828 if (!args) SWIG_fail;
30829 swig_obj[0] = args;
30830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30831 if (!SWIG_IsOK(res1)) {
30832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30833 }
30834 arg1 = reinterpret_cast< wxWindow * >(argp1);
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 (arg1)->Raise();
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 resultobj = SWIG_Py_Void();
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30849 PyObject *resultobj = 0;
30850 wxWindow *arg1 = (wxWindow *) 0 ;
30851 void *argp1 = 0 ;
30852 int res1 = 0 ;
30853 PyObject *swig_obj[1] ;
30854
30855 if (!args) SWIG_fail;
30856 swig_obj[0] = args;
30857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30858 if (!SWIG_IsOK(res1)) {
30859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30860 }
30861 arg1 = reinterpret_cast< wxWindow * >(argp1);
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 (arg1)->Lower();
30865 wxPyEndAllowThreads(__tstate);
30866 if (PyErr_Occurred()) SWIG_fail;
30867 }
30868 resultobj = SWIG_Py_Void();
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj = 0;
30877 wxWindow *arg1 = (wxWindow *) 0 ;
30878 wxSize *arg2 = 0 ;
30879 void *argp1 = 0 ;
30880 int res1 = 0 ;
30881 wxSize temp2 ;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 char * kwnames[] = {
30885 (char *) "self",(char *) "size", NULL
30886 };
30887
30888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30890 if (!SWIG_IsOK(res1)) {
30891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30892 }
30893 arg1 = reinterpret_cast< wxWindow * >(argp1);
30894 {
30895 arg2 = &temp2;
30896 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30897 }
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 (arg1)->SetClientSize((wxSize const &)*arg2);
30901 wxPyEndAllowThreads(__tstate);
30902 if (PyErr_Occurred()) SWIG_fail;
30903 }
30904 resultobj = SWIG_Py_Void();
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30912 PyObject *resultobj = 0;
30913 wxWindow *arg1 = (wxWindow *) 0 ;
30914 int arg2 ;
30915 int arg3 ;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 int val2 ;
30919 int ecode2 = 0 ;
30920 int val3 ;
30921 int ecode3 = 0 ;
30922 PyObject * obj0 = 0 ;
30923 PyObject * obj1 = 0 ;
30924 PyObject * obj2 = 0 ;
30925 char * kwnames[] = {
30926 (char *) "self",(char *) "width",(char *) "height", NULL
30927 };
30928
30929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30931 if (!SWIG_IsOK(res1)) {
30932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30933 }
30934 arg1 = reinterpret_cast< wxWindow * >(argp1);
30935 ecode2 = SWIG_AsVal_int(obj1, &val2);
30936 if (!SWIG_IsOK(ecode2)) {
30937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30938 }
30939 arg2 = static_cast< int >(val2);
30940 ecode3 = SWIG_AsVal_int(obj2, &val3);
30941 if (!SWIG_IsOK(ecode3)) {
30942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30943 }
30944 arg3 = static_cast< int >(val3);
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 (arg1)->SetClientSize(arg2,arg3);
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 resultobj = SWIG_Py_Void();
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30959 PyObject *resultobj = 0;
30960 wxWindow *arg1 = (wxWindow *) 0 ;
30961 wxRect *arg2 = 0 ;
30962 void *argp1 = 0 ;
30963 int res1 = 0 ;
30964 wxRect temp2 ;
30965 PyObject * obj0 = 0 ;
30966 PyObject * obj1 = 0 ;
30967 char * kwnames[] = {
30968 (char *) "self",(char *) "rect", NULL
30969 };
30970
30971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30973 if (!SWIG_IsOK(res1)) {
30974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30975 }
30976 arg1 = reinterpret_cast< wxWindow * >(argp1);
30977 {
30978 arg2 = &temp2;
30979 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30980 }
30981 {
30982 PyThreadState* __tstate = wxPyBeginAllowThreads();
30983 (arg1)->SetClientSize((wxRect const &)*arg2);
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 resultobj = SWIG_Py_Void();
30988 return resultobj;
30989 fail:
30990 return NULL;
30991 }
30992
30993
30994 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30995 PyObject *resultobj = 0;
30996 wxWindow *arg1 = (wxWindow *) 0 ;
30997 wxPoint result;
30998 void *argp1 = 0 ;
30999 int res1 = 0 ;
31000 PyObject *swig_obj[1] ;
31001
31002 if (!args) SWIG_fail;
31003 swig_obj[0] = args;
31004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31007 }
31008 arg1 = reinterpret_cast< wxWindow * >(argp1);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = ((wxWindow const *)arg1)->GetPosition();
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31023 PyObject *resultobj = 0;
31024 wxWindow *arg1 = (wxWindow *) 0 ;
31025 int *arg2 = (int *) 0 ;
31026 int *arg3 = (int *) 0 ;
31027 void *argp1 = 0 ;
31028 int res1 = 0 ;
31029 int temp2 ;
31030 int res2 = SWIG_TMPOBJ ;
31031 int temp3 ;
31032 int res3 = SWIG_TMPOBJ ;
31033 PyObject *swig_obj[1] ;
31034
31035 arg2 = &temp2;
31036 arg3 = &temp3;
31037 if (!args) SWIG_fail;
31038 swig_obj[0] = args;
31039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31042 }
31043 arg1 = reinterpret_cast< wxWindow * >(argp1);
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31047 wxPyEndAllowThreads(__tstate);
31048 if (PyErr_Occurred()) SWIG_fail;
31049 }
31050 resultobj = SWIG_Py_Void();
31051 if (SWIG_IsTmpObj(res2)) {
31052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31053 } else {
31054 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31056 }
31057 if (SWIG_IsTmpObj(res3)) {
31058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31059 } else {
31060 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31062 }
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 PyObject *resultobj = 0;
31071 wxWindow *arg1 = (wxWindow *) 0 ;
31072 wxPoint result;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 PyObject *swig_obj[1] ;
31076
31077 if (!args) SWIG_fail;
31078 swig_obj[0] = args;
31079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31080 if (!SWIG_IsOK(res1)) {
31081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31082 }
31083 arg1 = reinterpret_cast< wxWindow * >(argp1);
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 result = ((wxWindow const *)arg1)->GetScreenPosition();
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31098 PyObject *resultobj = 0;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 int *arg2 = (int *) 0 ;
31101 int *arg3 = (int *) 0 ;
31102 void *argp1 = 0 ;
31103 int res1 = 0 ;
31104 int temp2 ;
31105 int res2 = SWIG_TMPOBJ ;
31106 int temp3 ;
31107 int res3 = SWIG_TMPOBJ ;
31108 PyObject *swig_obj[1] ;
31109
31110 arg2 = &temp2;
31111 arg3 = &temp3;
31112 if (!args) SWIG_fail;
31113 swig_obj[0] = args;
31114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31117 }
31118 arg1 = reinterpret_cast< wxWindow * >(argp1);
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_Py_Void();
31126 if (SWIG_IsTmpObj(res2)) {
31127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31128 } else {
31129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31131 }
31132 if (SWIG_IsTmpObj(res3)) {
31133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31134 } else {
31135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31137 }
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31145 PyObject *resultobj = 0;
31146 wxWindow *arg1 = (wxWindow *) 0 ;
31147 wxRect result;
31148 void *argp1 = 0 ;
31149 int res1 = 0 ;
31150 PyObject *swig_obj[1] ;
31151
31152 if (!args) SWIG_fail;
31153 swig_obj[0] = args;
31154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31155 if (!SWIG_IsOK(res1)) {
31156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31157 }
31158 arg1 = reinterpret_cast< wxWindow * >(argp1);
31159 {
31160 PyThreadState* __tstate = wxPyBeginAllowThreads();
31161 result = ((wxWindow const *)arg1)->GetScreenRect();
31162 wxPyEndAllowThreads(__tstate);
31163 if (PyErr_Occurred()) SWIG_fail;
31164 }
31165 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31166 return resultobj;
31167 fail:
31168 return NULL;
31169 }
31170
31171
31172 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31173 PyObject *resultobj = 0;
31174 wxWindow *arg1 = (wxWindow *) 0 ;
31175 wxSize result;
31176 void *argp1 = 0 ;
31177 int res1 = 0 ;
31178 PyObject *swig_obj[1] ;
31179
31180 if (!args) SWIG_fail;
31181 swig_obj[0] = args;
31182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31183 if (!SWIG_IsOK(res1)) {
31184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31185 }
31186 arg1 = reinterpret_cast< wxWindow * >(argp1);
31187 {
31188 PyThreadState* __tstate = wxPyBeginAllowThreads();
31189 result = ((wxWindow const *)arg1)->GetSize();
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31201 PyObject *resultobj = 0;
31202 wxWindow *arg1 = (wxWindow *) 0 ;
31203 int *arg2 = (int *) 0 ;
31204 int *arg3 = (int *) 0 ;
31205 void *argp1 = 0 ;
31206 int res1 = 0 ;
31207 int temp2 ;
31208 int res2 = SWIG_TMPOBJ ;
31209 int temp3 ;
31210 int res3 = SWIG_TMPOBJ ;
31211 PyObject *swig_obj[1] ;
31212
31213 arg2 = &temp2;
31214 arg3 = &temp3;
31215 if (!args) SWIG_fail;
31216 swig_obj[0] = args;
31217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31220 }
31221 arg1 = reinterpret_cast< wxWindow * >(argp1);
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 resultobj = SWIG_Py_Void();
31229 if (SWIG_IsTmpObj(res2)) {
31230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31231 } else {
31232 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31234 }
31235 if (SWIG_IsTmpObj(res3)) {
31236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31237 } else {
31238 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31240 }
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 wxRect result;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 PyObject *swig_obj[1] ;
31254
31255 if (!args) SWIG_fail;
31256 swig_obj[0] = args;
31257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31258 if (!SWIG_IsOK(res1)) {
31259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31260 }
31261 arg1 = reinterpret_cast< wxWindow * >(argp1);
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = ((wxWindow const *)arg1)->GetRect();
31265 wxPyEndAllowThreads(__tstate);
31266 if (PyErr_Occurred()) SWIG_fail;
31267 }
31268 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31276 PyObject *resultobj = 0;
31277 wxWindow *arg1 = (wxWindow *) 0 ;
31278 wxSize result;
31279 void *argp1 = 0 ;
31280 int res1 = 0 ;
31281 PyObject *swig_obj[1] ;
31282
31283 if (!args) SWIG_fail;
31284 swig_obj[0] = args;
31285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31286 if (!SWIG_IsOK(res1)) {
31287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31288 }
31289 arg1 = reinterpret_cast< wxWindow * >(argp1);
31290 {
31291 PyThreadState* __tstate = wxPyBeginAllowThreads();
31292 result = ((wxWindow const *)arg1)->GetClientSize();
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31304 PyObject *resultobj = 0;
31305 wxWindow *arg1 = (wxWindow *) 0 ;
31306 int *arg2 = (int *) 0 ;
31307 int *arg3 = (int *) 0 ;
31308 void *argp1 = 0 ;
31309 int res1 = 0 ;
31310 int temp2 ;
31311 int res2 = SWIG_TMPOBJ ;
31312 int temp3 ;
31313 int res3 = SWIG_TMPOBJ ;
31314 PyObject *swig_obj[1] ;
31315
31316 arg2 = &temp2;
31317 arg3 = &temp3;
31318 if (!args) SWIG_fail;
31319 swig_obj[0] = args;
31320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31321 if (!SWIG_IsOK(res1)) {
31322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31323 }
31324 arg1 = reinterpret_cast< wxWindow * >(argp1);
31325 {
31326 PyThreadState* __tstate = wxPyBeginAllowThreads();
31327 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 resultobj = SWIG_Py_Void();
31332 if (SWIG_IsTmpObj(res2)) {
31333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31334 } else {
31335 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31337 }
31338 if (SWIG_IsTmpObj(res3)) {
31339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31340 } else {
31341 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31343 }
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31351 PyObject *resultobj = 0;
31352 wxWindow *arg1 = (wxWindow *) 0 ;
31353 wxPoint result;
31354 void *argp1 = 0 ;
31355 int res1 = 0 ;
31356 PyObject *swig_obj[1] ;
31357
31358 if (!args) SWIG_fail;
31359 swig_obj[0] = args;
31360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31363 }
31364 arg1 = reinterpret_cast< wxWindow * >(argp1);
31365 {
31366 PyThreadState* __tstate = wxPyBeginAllowThreads();
31367 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31368 wxPyEndAllowThreads(__tstate);
31369 if (PyErr_Occurred()) SWIG_fail;
31370 }
31371 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31372 return resultobj;
31373 fail:
31374 return NULL;
31375 }
31376
31377
31378 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31379 PyObject *resultobj = 0;
31380 wxWindow *arg1 = (wxWindow *) 0 ;
31381 wxRect result;
31382 void *argp1 = 0 ;
31383 int res1 = 0 ;
31384 PyObject *swig_obj[1] ;
31385
31386 if (!args) SWIG_fail;
31387 swig_obj[0] = args;
31388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31389 if (!SWIG_IsOK(res1)) {
31390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31391 }
31392 arg1 = reinterpret_cast< wxWindow * >(argp1);
31393 {
31394 PyThreadState* __tstate = wxPyBeginAllowThreads();
31395 result = ((wxWindow const *)arg1)->GetClientRect();
31396 wxPyEndAllowThreads(__tstate);
31397 if (PyErr_Occurred()) SWIG_fail;
31398 }
31399 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31407 PyObject *resultobj = 0;
31408 wxWindow *arg1 = (wxWindow *) 0 ;
31409 wxSize result;
31410 void *argp1 = 0 ;
31411 int res1 = 0 ;
31412 PyObject *swig_obj[1] ;
31413
31414 if (!args) SWIG_fail;
31415 swig_obj[0] = args;
31416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31417 if (!SWIG_IsOK(res1)) {
31418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31419 }
31420 arg1 = reinterpret_cast< wxWindow * >(argp1);
31421 {
31422 PyThreadState* __tstate = wxPyBeginAllowThreads();
31423 result = ((wxWindow const *)arg1)->GetBestSize();
31424 wxPyEndAllowThreads(__tstate);
31425 if (PyErr_Occurred()) SWIG_fail;
31426 }
31427 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31428 return resultobj;
31429 fail:
31430 return NULL;
31431 }
31432
31433
31434 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31435 PyObject *resultobj = 0;
31436 wxWindow *arg1 = (wxWindow *) 0 ;
31437 int *arg2 = (int *) 0 ;
31438 int *arg3 = (int *) 0 ;
31439 void *argp1 = 0 ;
31440 int res1 = 0 ;
31441 int temp2 ;
31442 int res2 = SWIG_TMPOBJ ;
31443 int temp3 ;
31444 int res3 = SWIG_TMPOBJ ;
31445 PyObject *swig_obj[1] ;
31446
31447 arg2 = &temp2;
31448 arg3 = &temp3;
31449 if (!args) SWIG_fail;
31450 swig_obj[0] = args;
31451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31452 if (!SWIG_IsOK(res1)) {
31453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31454 }
31455 arg1 = reinterpret_cast< wxWindow * >(argp1);
31456 {
31457 PyThreadState* __tstate = wxPyBeginAllowThreads();
31458 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31459 wxPyEndAllowThreads(__tstate);
31460 if (PyErr_Occurred()) SWIG_fail;
31461 }
31462 resultobj = SWIG_Py_Void();
31463 if (SWIG_IsTmpObj(res2)) {
31464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31465 } else {
31466 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31468 }
31469 if (SWIG_IsTmpObj(res3)) {
31470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31471 } else {
31472 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31474 }
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 PyObject *resultobj = 0;
31483 wxWindow *arg1 = (wxWindow *) 0 ;
31484 void *argp1 = 0 ;
31485 int res1 = 0 ;
31486 PyObject *swig_obj[1] ;
31487
31488 if (!args) SWIG_fail;
31489 swig_obj[0] = args;
31490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31491 if (!SWIG_IsOK(res1)) {
31492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31493 }
31494 arg1 = reinterpret_cast< wxWindow * >(argp1);
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 (arg1)->InvalidateBestSize();
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 resultobj = SWIG_Py_Void();
31502 return resultobj;
31503 fail:
31504 return NULL;
31505 }
31506
31507
31508 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31509 PyObject *resultobj = 0;
31510 wxWindow *arg1 = (wxWindow *) 0 ;
31511 wxSize *arg2 = 0 ;
31512 void *argp1 = 0 ;
31513 int res1 = 0 ;
31514 wxSize temp2 ;
31515 PyObject * obj0 = 0 ;
31516 PyObject * obj1 = 0 ;
31517 char * kwnames[] = {
31518 (char *) "self",(char *) "size", NULL
31519 };
31520
31521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31523 if (!SWIG_IsOK(res1)) {
31524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31525 }
31526 arg1 = reinterpret_cast< wxWindow * >(argp1);
31527 {
31528 arg2 = &temp2;
31529 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31530 }
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 resultobj = SWIG_Py_Void();
31538 return resultobj;
31539 fail:
31540 return NULL;
31541 }
31542
31543
31544 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31545 PyObject *resultobj = 0;
31546 wxWindow *arg1 = (wxWindow *) 0 ;
31547 wxSize result;
31548 void *argp1 = 0 ;
31549 int res1 = 0 ;
31550 PyObject *swig_obj[1] ;
31551
31552 if (!args) SWIG_fail;
31553 swig_obj[0] = args;
31554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31555 if (!SWIG_IsOK(res1)) {
31556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31557 }
31558 arg1 = reinterpret_cast< wxWindow * >(argp1);
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31573 PyObject *resultobj = 0;
31574 wxWindow *arg1 = (wxWindow *) 0 ;
31575 wxSize result;
31576 void *argp1 = 0 ;
31577 int res1 = 0 ;
31578 PyObject *swig_obj[1] ;
31579
31580 if (!args) SWIG_fail;
31581 swig_obj[0] = args;
31582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31583 if (!SWIG_IsOK(res1)) {
31584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31585 }
31586 arg1 = reinterpret_cast< wxWindow * >(argp1);
31587 {
31588 PyThreadState* __tstate = wxPyBeginAllowThreads();
31589 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31590 wxPyEndAllowThreads(__tstate);
31591 if (PyErr_Occurred()) SWIG_fail;
31592 }
31593 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31594 return resultobj;
31595 fail:
31596 return NULL;
31597 }
31598
31599
31600 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31601 PyObject *resultobj = 0;
31602 wxWindow *arg1 = (wxWindow *) 0 ;
31603 int arg2 = (int) wxBOTH ;
31604 void *argp1 = 0 ;
31605 int res1 = 0 ;
31606 int val2 ;
31607 int ecode2 = 0 ;
31608 PyObject * obj0 = 0 ;
31609 PyObject * obj1 = 0 ;
31610 char * kwnames[] = {
31611 (char *) "self",(char *) "direction", NULL
31612 };
31613
31614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31616 if (!SWIG_IsOK(res1)) {
31617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31618 }
31619 arg1 = reinterpret_cast< wxWindow * >(argp1);
31620 if (obj1) {
31621 ecode2 = SWIG_AsVal_int(obj1, &val2);
31622 if (!SWIG_IsOK(ecode2)) {
31623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31624 }
31625 arg2 = static_cast< int >(val2);
31626 }
31627 {
31628 PyThreadState* __tstate = wxPyBeginAllowThreads();
31629 (arg1)->Center(arg2);
31630 wxPyEndAllowThreads(__tstate);
31631 if (PyErr_Occurred()) SWIG_fail;
31632 }
31633 resultobj = SWIG_Py_Void();
31634 return resultobj;
31635 fail:
31636 return NULL;
31637 }
31638
31639
31640 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31641 PyObject *resultobj = 0;
31642 wxWindow *arg1 = (wxWindow *) 0 ;
31643 int arg2 = (int) wxBOTH ;
31644 void *argp1 = 0 ;
31645 int res1 = 0 ;
31646 int val2 ;
31647 int ecode2 = 0 ;
31648 PyObject * obj0 = 0 ;
31649 PyObject * obj1 = 0 ;
31650 char * kwnames[] = {
31651 (char *) "self",(char *) "dir", NULL
31652 };
31653
31654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31656 if (!SWIG_IsOK(res1)) {
31657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31658 }
31659 arg1 = reinterpret_cast< wxWindow * >(argp1);
31660 if (obj1) {
31661 ecode2 = SWIG_AsVal_int(obj1, &val2);
31662 if (!SWIG_IsOK(ecode2)) {
31663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31664 }
31665 arg2 = static_cast< int >(val2);
31666 }
31667 {
31668 PyThreadState* __tstate = wxPyBeginAllowThreads();
31669 (arg1)->CenterOnParent(arg2);
31670 wxPyEndAllowThreads(__tstate);
31671 if (PyErr_Occurred()) SWIG_fail;
31672 }
31673 resultobj = SWIG_Py_Void();
31674 return resultobj;
31675 fail:
31676 return NULL;
31677 }
31678
31679
31680 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31681 PyObject *resultobj = 0;
31682 wxWindow *arg1 = (wxWindow *) 0 ;
31683 void *argp1 = 0 ;
31684 int res1 = 0 ;
31685 PyObject *swig_obj[1] ;
31686
31687 if (!args) SWIG_fail;
31688 swig_obj[0] = args;
31689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31690 if (!SWIG_IsOK(res1)) {
31691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31692 }
31693 arg1 = reinterpret_cast< wxWindow * >(argp1);
31694 {
31695 PyThreadState* __tstate = wxPyBeginAllowThreads();
31696 (arg1)->Fit();
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 resultobj = SWIG_Py_Void();
31701 return resultobj;
31702 fail:
31703 return NULL;
31704 }
31705
31706
31707 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31708 PyObject *resultobj = 0;
31709 wxWindow *arg1 = (wxWindow *) 0 ;
31710 void *argp1 = 0 ;
31711 int res1 = 0 ;
31712 PyObject *swig_obj[1] ;
31713
31714 if (!args) SWIG_fail;
31715 swig_obj[0] = args;
31716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31717 if (!SWIG_IsOK(res1)) {
31718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31719 }
31720 arg1 = reinterpret_cast< wxWindow * >(argp1);
31721 {
31722 PyThreadState* __tstate = wxPyBeginAllowThreads();
31723 (arg1)->FitInside();
31724 wxPyEndAllowThreads(__tstate);
31725 if (PyErr_Occurred()) SWIG_fail;
31726 }
31727 resultobj = SWIG_Py_Void();
31728 return resultobj;
31729 fail:
31730 return NULL;
31731 }
31732
31733
31734 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31735 PyObject *resultobj = 0;
31736 wxWindow *arg1 = (wxWindow *) 0 ;
31737 int arg2 ;
31738 int arg3 ;
31739 int arg4 = (int) -1 ;
31740 int arg5 = (int) -1 ;
31741 int arg6 = (int) -1 ;
31742 int arg7 = (int) -1 ;
31743 void *argp1 = 0 ;
31744 int res1 = 0 ;
31745 int val2 ;
31746 int ecode2 = 0 ;
31747 int val3 ;
31748 int ecode3 = 0 ;
31749 int val4 ;
31750 int ecode4 = 0 ;
31751 int val5 ;
31752 int ecode5 = 0 ;
31753 int val6 ;
31754 int ecode6 = 0 ;
31755 int val7 ;
31756 int ecode7 = 0 ;
31757 PyObject * obj0 = 0 ;
31758 PyObject * obj1 = 0 ;
31759 PyObject * obj2 = 0 ;
31760 PyObject * obj3 = 0 ;
31761 PyObject * obj4 = 0 ;
31762 PyObject * obj5 = 0 ;
31763 PyObject * obj6 = 0 ;
31764 char * kwnames[] = {
31765 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31766 };
31767
31768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31770 if (!SWIG_IsOK(res1)) {
31771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31772 }
31773 arg1 = reinterpret_cast< wxWindow * >(argp1);
31774 ecode2 = SWIG_AsVal_int(obj1, &val2);
31775 if (!SWIG_IsOK(ecode2)) {
31776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31777 }
31778 arg2 = static_cast< int >(val2);
31779 ecode3 = SWIG_AsVal_int(obj2, &val3);
31780 if (!SWIG_IsOK(ecode3)) {
31781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31782 }
31783 arg3 = static_cast< int >(val3);
31784 if (obj3) {
31785 ecode4 = SWIG_AsVal_int(obj3, &val4);
31786 if (!SWIG_IsOK(ecode4)) {
31787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31788 }
31789 arg4 = static_cast< int >(val4);
31790 }
31791 if (obj4) {
31792 ecode5 = SWIG_AsVal_int(obj4, &val5);
31793 if (!SWIG_IsOK(ecode5)) {
31794 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31795 }
31796 arg5 = static_cast< int >(val5);
31797 }
31798 if (obj5) {
31799 ecode6 = SWIG_AsVal_int(obj5, &val6);
31800 if (!SWIG_IsOK(ecode6)) {
31801 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31802 }
31803 arg6 = static_cast< int >(val6);
31804 }
31805 if (obj6) {
31806 ecode7 = SWIG_AsVal_int(obj6, &val7);
31807 if (!SWIG_IsOK(ecode7)) {
31808 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31809 }
31810 arg7 = static_cast< int >(val7);
31811 }
31812 {
31813 PyThreadState* __tstate = wxPyBeginAllowThreads();
31814 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31815 wxPyEndAllowThreads(__tstate);
31816 if (PyErr_Occurred()) SWIG_fail;
31817 }
31818 resultobj = SWIG_Py_Void();
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31826 PyObject *resultobj = 0;
31827 wxWindow *arg1 = (wxWindow *) 0 ;
31828 wxSize *arg2 = 0 ;
31829 wxSize const &arg3_defvalue = wxDefaultSize ;
31830 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31831 wxSize const &arg4_defvalue = wxDefaultSize ;
31832 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31833 void *argp1 = 0 ;
31834 int res1 = 0 ;
31835 wxSize temp2 ;
31836 wxSize temp3 ;
31837 wxSize temp4 ;
31838 PyObject * obj0 = 0 ;
31839 PyObject * obj1 = 0 ;
31840 PyObject * obj2 = 0 ;
31841 PyObject * obj3 = 0 ;
31842 char * kwnames[] = {
31843 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31844 };
31845
31846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31848 if (!SWIG_IsOK(res1)) {
31849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31850 }
31851 arg1 = reinterpret_cast< wxWindow * >(argp1);
31852 {
31853 arg2 = &temp2;
31854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31855 }
31856 if (obj2) {
31857 {
31858 arg3 = &temp3;
31859 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31860 }
31861 }
31862 if (obj3) {
31863 {
31864 arg4 = &temp4;
31865 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31866 }
31867 }
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_Py_Void();
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31882 PyObject *resultobj = 0;
31883 wxWindow *arg1 = (wxWindow *) 0 ;
31884 int arg2 ;
31885 int arg3 ;
31886 int arg4 = (int) -1 ;
31887 int arg5 = (int) -1 ;
31888 void *argp1 = 0 ;
31889 int res1 = 0 ;
31890 int val2 ;
31891 int ecode2 = 0 ;
31892 int val3 ;
31893 int ecode3 = 0 ;
31894 int val4 ;
31895 int ecode4 = 0 ;
31896 int val5 ;
31897 int ecode5 = 0 ;
31898 PyObject * obj0 = 0 ;
31899 PyObject * obj1 = 0 ;
31900 PyObject * obj2 = 0 ;
31901 PyObject * obj3 = 0 ;
31902 PyObject * obj4 = 0 ;
31903 char * kwnames[] = {
31904 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31905 };
31906
31907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31909 if (!SWIG_IsOK(res1)) {
31910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31911 }
31912 arg1 = reinterpret_cast< wxWindow * >(argp1);
31913 ecode2 = SWIG_AsVal_int(obj1, &val2);
31914 if (!SWIG_IsOK(ecode2)) {
31915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31916 }
31917 arg2 = static_cast< int >(val2);
31918 ecode3 = SWIG_AsVal_int(obj2, &val3);
31919 if (!SWIG_IsOK(ecode3)) {
31920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31921 }
31922 arg3 = static_cast< int >(val3);
31923 if (obj3) {
31924 ecode4 = SWIG_AsVal_int(obj3, &val4);
31925 if (!SWIG_IsOK(ecode4)) {
31926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31927 }
31928 arg4 = static_cast< int >(val4);
31929 }
31930 if (obj4) {
31931 ecode5 = SWIG_AsVal_int(obj4, &val5);
31932 if (!SWIG_IsOK(ecode5)) {
31933 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31934 }
31935 arg5 = static_cast< int >(val5);
31936 }
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 resultobj = SWIG_Py_Void();
31944 return resultobj;
31945 fail:
31946 return NULL;
31947 }
31948
31949
31950 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31951 PyObject *resultobj = 0;
31952 wxWindow *arg1 = (wxWindow *) 0 ;
31953 wxSize *arg2 = 0 ;
31954 wxSize const &arg3_defvalue = wxDefaultSize ;
31955 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31956 void *argp1 = 0 ;
31957 int res1 = 0 ;
31958 wxSize temp2 ;
31959 wxSize temp3 ;
31960 PyObject * obj0 = 0 ;
31961 PyObject * obj1 = 0 ;
31962 PyObject * obj2 = 0 ;
31963 char * kwnames[] = {
31964 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31965 };
31966
31967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31969 if (!SWIG_IsOK(res1)) {
31970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31971 }
31972 arg1 = reinterpret_cast< wxWindow * >(argp1);
31973 {
31974 arg2 = &temp2;
31975 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31976 }
31977 if (obj2) {
31978 {
31979 arg3 = &temp3;
31980 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31981 }
31982 }
31983 {
31984 PyThreadState* __tstate = wxPyBeginAllowThreads();
31985 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31986 wxPyEndAllowThreads(__tstate);
31987 if (PyErr_Occurred()) SWIG_fail;
31988 }
31989 resultobj = SWIG_Py_Void();
31990 return resultobj;
31991 fail:
31992 return NULL;
31993 }
31994
31995
31996 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31997 PyObject *resultobj = 0;
31998 wxWindow *arg1 = (wxWindow *) 0 ;
31999 wxSize result;
32000 void *argp1 = 0 ;
32001 int res1 = 0 ;
32002 PyObject *swig_obj[1] ;
32003
32004 if (!args) SWIG_fail;
32005 swig_obj[0] = args;
32006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32007 if (!SWIG_IsOK(res1)) {
32008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32009 }
32010 arg1 = reinterpret_cast< wxWindow * >(argp1);
32011 {
32012 PyThreadState* __tstate = wxPyBeginAllowThreads();
32013 result = ((wxWindow const *)arg1)->GetMaxSize();
32014 wxPyEndAllowThreads(__tstate);
32015 if (PyErr_Occurred()) SWIG_fail;
32016 }
32017 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32018 return resultobj;
32019 fail:
32020 return NULL;
32021 }
32022
32023
32024 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32025 PyObject *resultobj = 0;
32026 wxWindow *arg1 = (wxWindow *) 0 ;
32027 wxSize result;
32028 void *argp1 = 0 ;
32029 int res1 = 0 ;
32030 PyObject *swig_obj[1] ;
32031
32032 if (!args) SWIG_fail;
32033 swig_obj[0] = args;
32034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32035 if (!SWIG_IsOK(res1)) {
32036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32037 }
32038 arg1 = reinterpret_cast< wxWindow * >(argp1);
32039 {
32040 PyThreadState* __tstate = wxPyBeginAllowThreads();
32041 result = ((wxWindow const *)arg1)->GetMinSize();
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32053 PyObject *resultobj = 0;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 wxSize *arg2 = 0 ;
32056 void *argp1 = 0 ;
32057 int res1 = 0 ;
32058 wxSize temp2 ;
32059 PyObject * obj0 = 0 ;
32060 PyObject * obj1 = 0 ;
32061 char * kwnames[] = {
32062 (char *) "self",(char *) "minSize", NULL
32063 };
32064
32065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32067 if (!SWIG_IsOK(res1)) {
32068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32069 }
32070 arg1 = reinterpret_cast< wxWindow * >(argp1);
32071 {
32072 arg2 = &temp2;
32073 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32074 }
32075 {
32076 PyThreadState* __tstate = wxPyBeginAllowThreads();
32077 (arg1)->SetMinSize((wxSize const &)*arg2);
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 resultobj = SWIG_Py_Void();
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32089 PyObject *resultobj = 0;
32090 wxWindow *arg1 = (wxWindow *) 0 ;
32091 wxSize *arg2 = 0 ;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 wxSize temp2 ;
32095 PyObject * obj0 = 0 ;
32096 PyObject * obj1 = 0 ;
32097 char * kwnames[] = {
32098 (char *) "self",(char *) "maxSize", NULL
32099 };
32100
32101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32105 }
32106 arg1 = reinterpret_cast< wxWindow * >(argp1);
32107 {
32108 arg2 = &temp2;
32109 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32110 }
32111 {
32112 PyThreadState* __tstate = wxPyBeginAllowThreads();
32113 (arg1)->SetMaxSize((wxSize const &)*arg2);
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 resultobj = SWIG_Py_Void();
32118 return resultobj;
32119 fail:
32120 return NULL;
32121 }
32122
32123
32124 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32125 PyObject *resultobj = 0;
32126 wxWindow *arg1 = (wxWindow *) 0 ;
32127 int result;
32128 void *argp1 = 0 ;
32129 int res1 = 0 ;
32130 PyObject *swig_obj[1] ;
32131
32132 if (!args) SWIG_fail;
32133 swig_obj[0] = args;
32134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32135 if (!SWIG_IsOK(res1)) {
32136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32137 }
32138 arg1 = reinterpret_cast< wxWindow * >(argp1);
32139 {
32140 PyThreadState* __tstate = wxPyBeginAllowThreads();
32141 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32142 wxPyEndAllowThreads(__tstate);
32143 if (PyErr_Occurred()) SWIG_fail;
32144 }
32145 resultobj = SWIG_From_int(static_cast< int >(result));
32146 return resultobj;
32147 fail:
32148 return NULL;
32149 }
32150
32151
32152 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32153 PyObject *resultobj = 0;
32154 wxWindow *arg1 = (wxWindow *) 0 ;
32155 int result;
32156 void *argp1 = 0 ;
32157 int res1 = 0 ;
32158 PyObject *swig_obj[1] ;
32159
32160 if (!args) SWIG_fail;
32161 swig_obj[0] = args;
32162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32163 if (!SWIG_IsOK(res1)) {
32164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32165 }
32166 arg1 = reinterpret_cast< wxWindow * >(argp1);
32167 {
32168 PyThreadState* __tstate = wxPyBeginAllowThreads();
32169 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 resultobj = SWIG_From_int(static_cast< int >(result));
32174 return resultobj;
32175 fail:
32176 return NULL;
32177 }
32178
32179
32180 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32181 PyObject *resultobj = 0;
32182 wxWindow *arg1 = (wxWindow *) 0 ;
32183 int result;
32184 void *argp1 = 0 ;
32185 int res1 = 0 ;
32186 PyObject *swig_obj[1] ;
32187
32188 if (!args) SWIG_fail;
32189 swig_obj[0] = args;
32190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32191 if (!SWIG_IsOK(res1)) {
32192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32193 }
32194 arg1 = reinterpret_cast< wxWindow * >(argp1);
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 resultobj = SWIG_From_int(static_cast< int >(result));
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxWindow *arg1 = (wxWindow *) 0 ;
32211 int result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject *swig_obj[1] ;
32215
32216 if (!args) SWIG_fail;
32217 swig_obj[0] = args;
32218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32219 if (!SWIG_IsOK(res1)) {
32220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32221 }
32222 arg1 = reinterpret_cast< wxWindow * >(argp1);
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 resultobj = SWIG_From_int(static_cast< int >(result));
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32237 PyObject *resultobj = 0;
32238 wxWindow *arg1 = (wxWindow *) 0 ;
32239 wxSize *arg2 = 0 ;
32240 void *argp1 = 0 ;
32241 int res1 = 0 ;
32242 wxSize temp2 ;
32243 PyObject * obj0 = 0 ;
32244 PyObject * obj1 = 0 ;
32245 char * kwnames[] = {
32246 (char *) "self",(char *) "size", NULL
32247 };
32248
32249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32251 if (!SWIG_IsOK(res1)) {
32252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32253 }
32254 arg1 = reinterpret_cast< wxWindow * >(argp1);
32255 {
32256 arg2 = &temp2;
32257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32258 }
32259 {
32260 PyThreadState* __tstate = wxPyBeginAllowThreads();
32261 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32262 wxPyEndAllowThreads(__tstate);
32263 if (PyErr_Occurred()) SWIG_fail;
32264 }
32265 resultobj = SWIG_Py_Void();
32266 return resultobj;
32267 fail:
32268 return NULL;
32269 }
32270
32271
32272 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32273 PyObject *resultobj = 0;
32274 wxWindow *arg1 = (wxWindow *) 0 ;
32275 int arg2 ;
32276 int arg3 ;
32277 void *argp1 = 0 ;
32278 int res1 = 0 ;
32279 int val2 ;
32280 int ecode2 = 0 ;
32281 int val3 ;
32282 int ecode3 = 0 ;
32283 PyObject * obj0 = 0 ;
32284 PyObject * obj1 = 0 ;
32285 PyObject * obj2 = 0 ;
32286 char * kwnames[] = {
32287 (char *) "self",(char *) "w",(char *) "h", NULL
32288 };
32289
32290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32292 if (!SWIG_IsOK(res1)) {
32293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32294 }
32295 arg1 = reinterpret_cast< wxWindow * >(argp1);
32296 ecode2 = SWIG_AsVal_int(obj1, &val2);
32297 if (!SWIG_IsOK(ecode2)) {
32298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32299 }
32300 arg2 = static_cast< int >(val2);
32301 ecode3 = SWIG_AsVal_int(obj2, &val3);
32302 if (!SWIG_IsOK(ecode3)) {
32303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32304 }
32305 arg3 = static_cast< int >(val3);
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 (arg1)->SetVirtualSize(arg2,arg3);
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 resultobj = SWIG_Py_Void();
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32320 PyObject *resultobj = 0;
32321 wxWindow *arg1 = (wxWindow *) 0 ;
32322 wxSize result;
32323 void *argp1 = 0 ;
32324 int res1 = 0 ;
32325 PyObject *swig_obj[1] ;
32326
32327 if (!args) SWIG_fail;
32328 swig_obj[0] = args;
32329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32330 if (!SWIG_IsOK(res1)) {
32331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32332 }
32333 arg1 = reinterpret_cast< wxWindow * >(argp1);
32334 {
32335 PyThreadState* __tstate = wxPyBeginAllowThreads();
32336 result = ((wxWindow const *)arg1)->GetVirtualSize();
32337 wxPyEndAllowThreads(__tstate);
32338 if (PyErr_Occurred()) SWIG_fail;
32339 }
32340 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32341 return resultobj;
32342 fail:
32343 return NULL;
32344 }
32345
32346
32347 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32348 PyObject *resultobj = 0;
32349 wxWindow *arg1 = (wxWindow *) 0 ;
32350 int *arg2 = (int *) 0 ;
32351 int *arg3 = (int *) 0 ;
32352 void *argp1 = 0 ;
32353 int res1 = 0 ;
32354 int temp2 ;
32355 int res2 = SWIG_TMPOBJ ;
32356 int temp3 ;
32357 int res3 = SWIG_TMPOBJ ;
32358 PyObject *swig_obj[1] ;
32359
32360 arg2 = &temp2;
32361 arg3 = &temp3;
32362 if (!args) SWIG_fail;
32363 swig_obj[0] = args;
32364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32365 if (!SWIG_IsOK(res1)) {
32366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32367 }
32368 arg1 = reinterpret_cast< wxWindow * >(argp1);
32369 {
32370 PyThreadState* __tstate = wxPyBeginAllowThreads();
32371 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32372 wxPyEndAllowThreads(__tstate);
32373 if (PyErr_Occurred()) SWIG_fail;
32374 }
32375 resultobj = SWIG_Py_Void();
32376 if (SWIG_IsTmpObj(res2)) {
32377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32378 } else {
32379 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32381 }
32382 if (SWIG_IsTmpObj(res3)) {
32383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32384 } else {
32385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32387 }
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 wxSize result;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 PyObject *swig_obj[1] ;
32401
32402 if (!args) SWIG_fail;
32403 swig_obj[0] = args;
32404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32407 }
32408 arg1 = reinterpret_cast< wxWindow * >(argp1);
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32416 return resultobj;
32417 fail:
32418 return NULL;
32419 }
32420
32421
32422 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32423 PyObject *resultobj = 0;
32424 wxWindow *arg1 = (wxWindow *) 0 ;
32425 bool arg2 = (bool) true ;
32426 bool result;
32427 void *argp1 = 0 ;
32428 int res1 = 0 ;
32429 bool val2 ;
32430 int ecode2 = 0 ;
32431 PyObject * obj0 = 0 ;
32432 PyObject * obj1 = 0 ;
32433 char * kwnames[] = {
32434 (char *) "self",(char *) "show", NULL
32435 };
32436
32437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32439 if (!SWIG_IsOK(res1)) {
32440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32441 }
32442 arg1 = reinterpret_cast< wxWindow * >(argp1);
32443 if (obj1) {
32444 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32445 if (!SWIG_IsOK(ecode2)) {
32446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32447 }
32448 arg2 = static_cast< bool >(val2);
32449 }
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 result = (bool)(arg1)->Show(arg2);
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 {
32457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32458 }
32459 return resultobj;
32460 fail:
32461 return NULL;
32462 }
32463
32464
32465 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 PyObject *resultobj = 0;
32467 wxWindow *arg1 = (wxWindow *) 0 ;
32468 bool result;
32469 void *argp1 = 0 ;
32470 int res1 = 0 ;
32471 PyObject *swig_obj[1] ;
32472
32473 if (!args) SWIG_fail;
32474 swig_obj[0] = args;
32475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32476 if (!SWIG_IsOK(res1)) {
32477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32478 }
32479 arg1 = reinterpret_cast< wxWindow * >(argp1);
32480 {
32481 PyThreadState* __tstate = wxPyBeginAllowThreads();
32482 result = (bool)(arg1)->Hide();
32483 wxPyEndAllowThreads(__tstate);
32484 if (PyErr_Occurred()) SWIG_fail;
32485 }
32486 {
32487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32488 }
32489 return resultobj;
32490 fail:
32491 return NULL;
32492 }
32493
32494
32495 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32496 PyObject *resultobj = 0;
32497 wxWindow *arg1 = (wxWindow *) 0 ;
32498 bool arg2 = (bool) true ;
32499 bool result;
32500 void *argp1 = 0 ;
32501 int res1 = 0 ;
32502 bool val2 ;
32503 int ecode2 = 0 ;
32504 PyObject * obj0 = 0 ;
32505 PyObject * obj1 = 0 ;
32506 char * kwnames[] = {
32507 (char *) "self",(char *) "enable", NULL
32508 };
32509
32510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32512 if (!SWIG_IsOK(res1)) {
32513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32514 }
32515 arg1 = reinterpret_cast< wxWindow * >(argp1);
32516 if (obj1) {
32517 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32518 if (!SWIG_IsOK(ecode2)) {
32519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32520 }
32521 arg2 = static_cast< bool >(val2);
32522 }
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 result = (bool)(arg1)->Enable(arg2);
32526 wxPyEndAllowThreads(__tstate);
32527 if (PyErr_Occurred()) SWIG_fail;
32528 }
32529 {
32530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32531 }
32532 return resultobj;
32533 fail:
32534 return NULL;
32535 }
32536
32537
32538 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32539 PyObject *resultobj = 0;
32540 wxWindow *arg1 = (wxWindow *) 0 ;
32541 bool result;
32542 void *argp1 = 0 ;
32543 int res1 = 0 ;
32544 PyObject *swig_obj[1] ;
32545
32546 if (!args) SWIG_fail;
32547 swig_obj[0] = args;
32548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32549 if (!SWIG_IsOK(res1)) {
32550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32551 }
32552 arg1 = reinterpret_cast< wxWindow * >(argp1);
32553 {
32554 PyThreadState* __tstate = wxPyBeginAllowThreads();
32555 result = (bool)(arg1)->Disable();
32556 wxPyEndAllowThreads(__tstate);
32557 if (PyErr_Occurred()) SWIG_fail;
32558 }
32559 {
32560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32561 }
32562 return resultobj;
32563 fail:
32564 return NULL;
32565 }
32566
32567
32568 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32569 PyObject *resultobj = 0;
32570 wxWindow *arg1 = (wxWindow *) 0 ;
32571 bool result;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 PyObject *swig_obj[1] ;
32575
32576 if (!args) SWIG_fail;
32577 swig_obj[0] = args;
32578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32579 if (!SWIG_IsOK(res1)) {
32580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32581 }
32582 arg1 = reinterpret_cast< wxWindow * >(argp1);
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 result = (bool)((wxWindow const *)arg1)->IsShown();
32586 wxPyEndAllowThreads(__tstate);
32587 if (PyErr_Occurred()) SWIG_fail;
32588 }
32589 {
32590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32591 }
32592 return resultobj;
32593 fail:
32594 return NULL;
32595 }
32596
32597
32598 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32599 PyObject *resultobj = 0;
32600 wxWindow *arg1 = (wxWindow *) 0 ;
32601 bool result;
32602 void *argp1 = 0 ;
32603 int res1 = 0 ;
32604 PyObject *swig_obj[1] ;
32605
32606 if (!args) SWIG_fail;
32607 swig_obj[0] = args;
32608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32609 if (!SWIG_IsOK(res1)) {
32610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32611 }
32612 arg1 = reinterpret_cast< wxWindow * >(argp1);
32613 {
32614 PyThreadState* __tstate = wxPyBeginAllowThreads();
32615 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32616 wxPyEndAllowThreads(__tstate);
32617 if (PyErr_Occurred()) SWIG_fail;
32618 }
32619 {
32620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32621 }
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32629 PyObject *resultobj = 0;
32630 wxWindow *arg1 = (wxWindow *) 0 ;
32631 long arg2 ;
32632 void *argp1 = 0 ;
32633 int res1 = 0 ;
32634 long val2 ;
32635 int ecode2 = 0 ;
32636 PyObject * obj0 = 0 ;
32637 PyObject * obj1 = 0 ;
32638 char * kwnames[] = {
32639 (char *) "self",(char *) "style", NULL
32640 };
32641
32642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32644 if (!SWIG_IsOK(res1)) {
32645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32646 }
32647 arg1 = reinterpret_cast< wxWindow * >(argp1);
32648 ecode2 = SWIG_AsVal_long(obj1, &val2);
32649 if (!SWIG_IsOK(ecode2)) {
32650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32651 }
32652 arg2 = static_cast< long >(val2);
32653 {
32654 PyThreadState* __tstate = wxPyBeginAllowThreads();
32655 (arg1)->SetWindowStyleFlag(arg2);
32656 wxPyEndAllowThreads(__tstate);
32657 if (PyErr_Occurred()) SWIG_fail;
32658 }
32659 resultobj = SWIG_Py_Void();
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 PyObject *resultobj = 0;
32668 wxWindow *arg1 = (wxWindow *) 0 ;
32669 long result;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 PyObject *swig_obj[1] ;
32673
32674 if (!args) SWIG_fail;
32675 swig_obj[0] = args;
32676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32679 }
32680 arg1 = reinterpret_cast< wxWindow * >(argp1);
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32684 wxPyEndAllowThreads(__tstate);
32685 if (PyErr_Occurred()) SWIG_fail;
32686 }
32687 resultobj = SWIG_From_long(static_cast< long >(result));
32688 return resultobj;
32689 fail:
32690 return NULL;
32691 }
32692
32693
32694 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32695 PyObject *resultobj = 0;
32696 wxWindow *arg1 = (wxWindow *) 0 ;
32697 int arg2 ;
32698 bool result;
32699 void *argp1 = 0 ;
32700 int res1 = 0 ;
32701 int val2 ;
32702 int ecode2 = 0 ;
32703 PyObject * obj0 = 0 ;
32704 PyObject * obj1 = 0 ;
32705 char * kwnames[] = {
32706 (char *) "self",(char *) "flag", NULL
32707 };
32708
32709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32711 if (!SWIG_IsOK(res1)) {
32712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32713 }
32714 arg1 = reinterpret_cast< wxWindow * >(argp1);
32715 ecode2 = SWIG_AsVal_int(obj1, &val2);
32716 if (!SWIG_IsOK(ecode2)) {
32717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32718 }
32719 arg2 = static_cast< int >(val2);
32720 {
32721 PyThreadState* __tstate = wxPyBeginAllowThreads();
32722 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32723 wxPyEndAllowThreads(__tstate);
32724 if (PyErr_Occurred()) SWIG_fail;
32725 }
32726 {
32727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32728 }
32729 return resultobj;
32730 fail:
32731 return NULL;
32732 }
32733
32734
32735 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32736 PyObject *resultobj = 0;
32737 wxWindow *arg1 = (wxWindow *) 0 ;
32738 bool result;
32739 void *argp1 = 0 ;
32740 int res1 = 0 ;
32741 PyObject *swig_obj[1] ;
32742
32743 if (!args) SWIG_fail;
32744 swig_obj[0] = args;
32745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32746 if (!SWIG_IsOK(res1)) {
32747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32748 }
32749 arg1 = reinterpret_cast< wxWindow * >(argp1);
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 result = (bool)((wxWindow const *)arg1)->IsRetained();
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 {
32757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32758 }
32759 return resultobj;
32760 fail:
32761 return NULL;
32762 }
32763
32764
32765 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32766 PyObject *resultobj = 0;
32767 wxWindow *arg1 = (wxWindow *) 0 ;
32768 long arg2 ;
32769 void *argp1 = 0 ;
32770 int res1 = 0 ;
32771 long val2 ;
32772 int ecode2 = 0 ;
32773 PyObject * obj0 = 0 ;
32774 PyObject * obj1 = 0 ;
32775 char * kwnames[] = {
32776 (char *) "self",(char *) "exStyle", NULL
32777 };
32778
32779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32781 if (!SWIG_IsOK(res1)) {
32782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32783 }
32784 arg1 = reinterpret_cast< wxWindow * >(argp1);
32785 ecode2 = SWIG_AsVal_long(obj1, &val2);
32786 if (!SWIG_IsOK(ecode2)) {
32787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32788 }
32789 arg2 = static_cast< long >(val2);
32790 {
32791 PyThreadState* __tstate = wxPyBeginAllowThreads();
32792 (arg1)->SetExtraStyle(arg2);
32793 wxPyEndAllowThreads(__tstate);
32794 if (PyErr_Occurred()) SWIG_fail;
32795 }
32796 resultobj = SWIG_Py_Void();
32797 return resultobj;
32798 fail:
32799 return NULL;
32800 }
32801
32802
32803 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32804 PyObject *resultobj = 0;
32805 wxWindow *arg1 = (wxWindow *) 0 ;
32806 long result;
32807 void *argp1 = 0 ;
32808 int res1 = 0 ;
32809 PyObject *swig_obj[1] ;
32810
32811 if (!args) SWIG_fail;
32812 swig_obj[0] = args;
32813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32814 if (!SWIG_IsOK(res1)) {
32815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32816 }
32817 arg1 = reinterpret_cast< wxWindow * >(argp1);
32818 {
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32821 wxPyEndAllowThreads(__tstate);
32822 if (PyErr_Occurred()) SWIG_fail;
32823 }
32824 resultobj = SWIG_From_long(static_cast< long >(result));
32825 return resultobj;
32826 fail:
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32832 PyObject *resultobj = 0;
32833 wxWindow *arg1 = (wxWindow *) 0 ;
32834 bool arg2 = (bool) true ;
32835 void *argp1 = 0 ;
32836 int res1 = 0 ;
32837 bool val2 ;
32838 int ecode2 = 0 ;
32839 PyObject * obj0 = 0 ;
32840 PyObject * obj1 = 0 ;
32841 char * kwnames[] = {
32842 (char *) "self",(char *) "modal", NULL
32843 };
32844
32845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32847 if (!SWIG_IsOK(res1)) {
32848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32849 }
32850 arg1 = reinterpret_cast< wxWindow * >(argp1);
32851 if (obj1) {
32852 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32853 if (!SWIG_IsOK(ecode2)) {
32854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32855 }
32856 arg2 = static_cast< bool >(val2);
32857 }
32858 {
32859 PyThreadState* __tstate = wxPyBeginAllowThreads();
32860 (arg1)->MakeModal(arg2);
32861 wxPyEndAllowThreads(__tstate);
32862 if (PyErr_Occurred()) SWIG_fail;
32863 }
32864 resultobj = SWIG_Py_Void();
32865 return resultobj;
32866 fail:
32867 return NULL;
32868 }
32869
32870
32871 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32872 PyObject *resultobj = 0;
32873 wxWindow *arg1 = (wxWindow *) 0 ;
32874 bool arg2 ;
32875 void *argp1 = 0 ;
32876 int res1 = 0 ;
32877 bool val2 ;
32878 int ecode2 = 0 ;
32879 PyObject * obj0 = 0 ;
32880 PyObject * obj1 = 0 ;
32881 char * kwnames[] = {
32882 (char *) "self",(char *) "enableTheme", NULL
32883 };
32884
32885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32889 }
32890 arg1 = reinterpret_cast< wxWindow * >(argp1);
32891 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32892 if (!SWIG_IsOK(ecode2)) {
32893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32894 }
32895 arg2 = static_cast< bool >(val2);
32896 {
32897 PyThreadState* __tstate = wxPyBeginAllowThreads();
32898 (arg1)->SetThemeEnabled(arg2);
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 resultobj = SWIG_Py_Void();
32903 return resultobj;
32904 fail:
32905 return NULL;
32906 }
32907
32908
32909 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32910 PyObject *resultobj = 0;
32911 wxWindow *arg1 = (wxWindow *) 0 ;
32912 bool result;
32913 void *argp1 = 0 ;
32914 int res1 = 0 ;
32915 PyObject *swig_obj[1] ;
32916
32917 if (!args) SWIG_fail;
32918 swig_obj[0] = args;
32919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32920 if (!SWIG_IsOK(res1)) {
32921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32922 }
32923 arg1 = reinterpret_cast< wxWindow * >(argp1);
32924 {
32925 PyThreadState* __tstate = wxPyBeginAllowThreads();
32926 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32927 wxPyEndAllowThreads(__tstate);
32928 if (PyErr_Occurred()) SWIG_fail;
32929 }
32930 {
32931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32932 }
32933 return resultobj;
32934 fail:
32935 return NULL;
32936 }
32937
32938
32939 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32940 PyObject *resultobj = 0;
32941 wxWindow *arg1 = (wxWindow *) 0 ;
32942 void *argp1 = 0 ;
32943 int res1 = 0 ;
32944 PyObject *swig_obj[1] ;
32945
32946 if (!args) SWIG_fail;
32947 swig_obj[0] = args;
32948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32949 if (!SWIG_IsOK(res1)) {
32950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32951 }
32952 arg1 = reinterpret_cast< wxWindow * >(argp1);
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 (arg1)->SetFocus();
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 resultobj = SWIG_Py_Void();
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 void *argp1 = 0 ;
32970 int res1 = 0 ;
32971 PyObject *swig_obj[1] ;
32972
32973 if (!args) SWIG_fail;
32974 swig_obj[0] = args;
32975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32978 }
32979 arg1 = reinterpret_cast< wxWindow * >(argp1);
32980 {
32981 PyThreadState* __tstate = wxPyBeginAllowThreads();
32982 (arg1)->SetFocusFromKbd();
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 resultobj = SWIG_Py_Void();
32987 return resultobj;
32988 fail:
32989 return NULL;
32990 }
32991
32992
32993 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32994 PyObject *resultobj = 0;
32995 wxWindow *result = 0 ;
32996
32997 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32998 {
32999 if (!wxPyCheckForApp()) SWIG_fail;
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (wxWindow *)wxWindow::FindFocus();
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 {
33006 resultobj = wxPyMake_wxObject(result, 0);
33007 }
33008 return resultobj;
33009 fail:
33010 return NULL;
33011 }
33012
33013
33014 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33015 PyObject *resultobj = 0;
33016 wxWindow *arg1 = (wxWindow *) 0 ;
33017 bool result;
33018 void *argp1 = 0 ;
33019 int res1 = 0 ;
33020 PyObject *swig_obj[1] ;
33021
33022 if (!args) SWIG_fail;
33023 swig_obj[0] = args;
33024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33025 if (!SWIG_IsOK(res1)) {
33026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33027 }
33028 arg1 = reinterpret_cast< wxWindow * >(argp1);
33029 {
33030 PyThreadState* __tstate = wxPyBeginAllowThreads();
33031 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33032 wxPyEndAllowThreads(__tstate);
33033 if (PyErr_Occurred()) SWIG_fail;
33034 }
33035 {
33036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33037 }
33038 return resultobj;
33039 fail:
33040 return NULL;
33041 }
33042
33043
33044 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33045 PyObject *resultobj = 0;
33046 wxWindow *arg1 = (wxWindow *) 0 ;
33047 bool result;
33048 void *argp1 = 0 ;
33049 int res1 = 0 ;
33050 PyObject *swig_obj[1] ;
33051
33052 if (!args) SWIG_fail;
33053 swig_obj[0] = args;
33054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33055 if (!SWIG_IsOK(res1)) {
33056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33057 }
33058 arg1 = reinterpret_cast< wxWindow * >(argp1);
33059 {
33060 PyThreadState* __tstate = wxPyBeginAllowThreads();
33061 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33062 wxPyEndAllowThreads(__tstate);
33063 if (PyErr_Occurred()) SWIG_fail;
33064 }
33065 {
33066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33067 }
33068 return resultobj;
33069 fail:
33070 return NULL;
33071 }
33072
33073
33074 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33075 PyObject *resultobj = 0;
33076 wxWindow *arg1 = (wxWindow *) 0 ;
33077 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33078 bool result;
33079 void *argp1 = 0 ;
33080 int res1 = 0 ;
33081 int val2 ;
33082 int ecode2 = 0 ;
33083 PyObject * obj0 = 0 ;
33084 PyObject * obj1 = 0 ;
33085 char * kwnames[] = {
33086 (char *) "self",(char *) "flags", NULL
33087 };
33088
33089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33091 if (!SWIG_IsOK(res1)) {
33092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33093 }
33094 arg1 = reinterpret_cast< wxWindow * >(argp1);
33095 if (obj1) {
33096 ecode2 = SWIG_AsVal_int(obj1, &val2);
33097 if (!SWIG_IsOK(ecode2)) {
33098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33099 }
33100 arg2 = static_cast< int >(val2);
33101 }
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 result = (bool)(arg1)->Navigate(arg2);
33105 wxPyEndAllowThreads(__tstate);
33106 if (PyErr_Occurred()) SWIG_fail;
33107 }
33108 {
33109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33110 }
33111 return resultobj;
33112 fail:
33113 return NULL;
33114 }
33115
33116
33117 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33118 PyObject *resultobj = 0;
33119 wxWindow *arg1 = (wxWindow *) 0 ;
33120 wxWindow *arg2 = (wxWindow *) 0 ;
33121 void *argp1 = 0 ;
33122 int res1 = 0 ;
33123 void *argp2 = 0 ;
33124 int res2 = 0 ;
33125 PyObject * obj0 = 0 ;
33126 PyObject * obj1 = 0 ;
33127 char * kwnames[] = {
33128 (char *) "self",(char *) "win", NULL
33129 };
33130
33131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33133 if (!SWIG_IsOK(res1)) {
33134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33138 if (!SWIG_IsOK(res2)) {
33139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33140 }
33141 arg2 = reinterpret_cast< wxWindow * >(argp2);
33142 {
33143 PyThreadState* __tstate = wxPyBeginAllowThreads();
33144 (arg1)->MoveAfterInTabOrder(arg2);
33145 wxPyEndAllowThreads(__tstate);
33146 if (PyErr_Occurred()) SWIG_fail;
33147 }
33148 resultobj = SWIG_Py_Void();
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33156 PyObject *resultobj = 0;
33157 wxWindow *arg1 = (wxWindow *) 0 ;
33158 wxWindow *arg2 = (wxWindow *) 0 ;
33159 void *argp1 = 0 ;
33160 int res1 = 0 ;
33161 void *argp2 = 0 ;
33162 int res2 = 0 ;
33163 PyObject * obj0 = 0 ;
33164 PyObject * obj1 = 0 ;
33165 char * kwnames[] = {
33166 (char *) "self",(char *) "win", NULL
33167 };
33168
33169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33171 if (!SWIG_IsOK(res1)) {
33172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33173 }
33174 arg1 = reinterpret_cast< wxWindow * >(argp1);
33175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33176 if (!SWIG_IsOK(res2)) {
33177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33178 }
33179 arg2 = reinterpret_cast< wxWindow * >(argp2);
33180 {
33181 PyThreadState* __tstate = wxPyBeginAllowThreads();
33182 (arg1)->MoveBeforeInTabOrder(arg2);
33183 wxPyEndAllowThreads(__tstate);
33184 if (PyErr_Occurred()) SWIG_fail;
33185 }
33186 resultobj = SWIG_Py_Void();
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33194 PyObject *resultobj = 0;
33195 wxWindow *arg1 = (wxWindow *) 0 ;
33196 PyObject *result = 0 ;
33197 void *argp1 = 0 ;
33198 int res1 = 0 ;
33199 PyObject *swig_obj[1] ;
33200
33201 if (!args) SWIG_fail;
33202 swig_obj[0] = args;
33203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33204 if (!SWIG_IsOK(res1)) {
33205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33206 }
33207 arg1 = reinterpret_cast< wxWindow * >(argp1);
33208 {
33209 PyThreadState* __tstate = wxPyBeginAllowThreads();
33210 result = (PyObject *)wxWindow_GetChildren(arg1);
33211 wxPyEndAllowThreads(__tstate);
33212 if (PyErr_Occurred()) SWIG_fail;
33213 }
33214 resultobj = result;
33215 return resultobj;
33216 fail:
33217 return NULL;
33218 }
33219
33220
33221 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33222 PyObject *resultobj = 0;
33223 wxWindow *arg1 = (wxWindow *) 0 ;
33224 wxWindow *result = 0 ;
33225 void *argp1 = 0 ;
33226 int res1 = 0 ;
33227 PyObject *swig_obj[1] ;
33228
33229 if (!args) SWIG_fail;
33230 swig_obj[0] = args;
33231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33232 if (!SWIG_IsOK(res1)) {
33233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33234 }
33235 arg1 = reinterpret_cast< wxWindow * >(argp1);
33236 {
33237 PyThreadState* __tstate = wxPyBeginAllowThreads();
33238 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33239 wxPyEndAllowThreads(__tstate);
33240 if (PyErr_Occurred()) SWIG_fail;
33241 }
33242 {
33243 resultobj = wxPyMake_wxObject(result, 0);
33244 }
33245 return resultobj;
33246 fail:
33247 return NULL;
33248 }
33249
33250
33251 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33252 PyObject *resultobj = 0;
33253 wxWindow *arg1 = (wxWindow *) 0 ;
33254 wxWindow *result = 0 ;
33255 void *argp1 = 0 ;
33256 int res1 = 0 ;
33257 PyObject *swig_obj[1] ;
33258
33259 if (!args) SWIG_fail;
33260 swig_obj[0] = args;
33261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33262 if (!SWIG_IsOK(res1)) {
33263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33264 }
33265 arg1 = reinterpret_cast< wxWindow * >(argp1);
33266 {
33267 PyThreadState* __tstate = wxPyBeginAllowThreads();
33268 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33269 wxPyEndAllowThreads(__tstate);
33270 if (PyErr_Occurred()) SWIG_fail;
33271 }
33272 {
33273 resultobj = wxPyMake_wxObject(result, 0);
33274 }
33275 return resultobj;
33276 fail:
33277 return NULL;
33278 }
33279
33280
33281 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33282 PyObject *resultobj = 0;
33283 wxWindow *arg1 = (wxWindow *) 0 ;
33284 bool result;
33285 void *argp1 = 0 ;
33286 int res1 = 0 ;
33287 PyObject *swig_obj[1] ;
33288
33289 if (!args) SWIG_fail;
33290 swig_obj[0] = args;
33291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33292 if (!SWIG_IsOK(res1)) {
33293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33294 }
33295 arg1 = reinterpret_cast< wxWindow * >(argp1);
33296 {
33297 PyThreadState* __tstate = wxPyBeginAllowThreads();
33298 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33299 wxPyEndAllowThreads(__tstate);
33300 if (PyErr_Occurred()) SWIG_fail;
33301 }
33302 {
33303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33304 }
33305 return resultobj;
33306 fail:
33307 return NULL;
33308 }
33309
33310
33311 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33312 PyObject *resultobj = 0;
33313 wxWindow *arg1 = (wxWindow *) 0 ;
33314 wxWindow *arg2 = (wxWindow *) 0 ;
33315 bool result;
33316 void *argp1 = 0 ;
33317 int res1 = 0 ;
33318 void *argp2 = 0 ;
33319 int res2 = 0 ;
33320 PyObject * obj0 = 0 ;
33321 PyObject * obj1 = 0 ;
33322 char * kwnames[] = {
33323 (char *) "self",(char *) "newParent", NULL
33324 };
33325
33326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33328 if (!SWIG_IsOK(res1)) {
33329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33330 }
33331 arg1 = reinterpret_cast< wxWindow * >(argp1);
33332 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33333 if (!SWIG_IsOK(res2)) {
33334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33335 }
33336 arg2 = reinterpret_cast< wxWindow * >(argp2);
33337 {
33338 PyThreadState* __tstate = wxPyBeginAllowThreads();
33339 result = (bool)(arg1)->Reparent(arg2);
33340 wxPyEndAllowThreads(__tstate);
33341 if (PyErr_Occurred()) SWIG_fail;
33342 }
33343 {
33344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33345 }
33346 return resultobj;
33347 fail:
33348 return NULL;
33349 }
33350
33351
33352 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33353 PyObject *resultobj = 0;
33354 wxWindow *arg1 = (wxWindow *) 0 ;
33355 wxWindow *arg2 = (wxWindow *) 0 ;
33356 void *argp1 = 0 ;
33357 int res1 = 0 ;
33358 void *argp2 = 0 ;
33359 int res2 = 0 ;
33360 PyObject * obj0 = 0 ;
33361 PyObject * obj1 = 0 ;
33362 char * kwnames[] = {
33363 (char *) "self",(char *) "child", NULL
33364 };
33365
33366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33368 if (!SWIG_IsOK(res1)) {
33369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33370 }
33371 arg1 = reinterpret_cast< wxWindow * >(argp1);
33372 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33373 if (!SWIG_IsOK(res2)) {
33374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33375 }
33376 arg2 = reinterpret_cast< wxWindow * >(argp2);
33377 {
33378 PyThreadState* __tstate = wxPyBeginAllowThreads();
33379 (arg1)->AddChild(arg2);
33380 wxPyEndAllowThreads(__tstate);
33381 if (PyErr_Occurred()) SWIG_fail;
33382 }
33383 resultobj = SWIG_Py_Void();
33384 return resultobj;
33385 fail:
33386 return NULL;
33387 }
33388
33389
33390 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33391 PyObject *resultobj = 0;
33392 wxWindow *arg1 = (wxWindow *) 0 ;
33393 wxWindow *arg2 = (wxWindow *) 0 ;
33394 void *argp1 = 0 ;
33395 int res1 = 0 ;
33396 void *argp2 = 0 ;
33397 int res2 = 0 ;
33398 PyObject * obj0 = 0 ;
33399 PyObject * obj1 = 0 ;
33400 char * kwnames[] = {
33401 (char *) "self",(char *) "child", NULL
33402 };
33403
33404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33406 if (!SWIG_IsOK(res1)) {
33407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33408 }
33409 arg1 = reinterpret_cast< wxWindow * >(argp1);
33410 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33411 if (!SWIG_IsOK(res2)) {
33412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33413 }
33414 arg2 = reinterpret_cast< wxWindow * >(argp2);
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 (arg1)->RemoveChild(arg2);
33418 wxPyEndAllowThreads(__tstate);
33419 if (PyErr_Occurred()) SWIG_fail;
33420 }
33421 resultobj = SWIG_Py_Void();
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33429 PyObject *resultobj = 0;
33430 wxWindow *arg1 = (wxWindow *) 0 ;
33431 bool arg2 ;
33432 void *argp1 = 0 ;
33433 int res1 = 0 ;
33434 bool val2 ;
33435 int ecode2 = 0 ;
33436 PyObject * obj0 = 0 ;
33437 PyObject * obj1 = 0 ;
33438 char * kwnames[] = {
33439 (char *) "self",(char *) "on", NULL
33440 };
33441
33442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33444 if (!SWIG_IsOK(res1)) {
33445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33446 }
33447 arg1 = reinterpret_cast< wxWindow * >(argp1);
33448 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33449 if (!SWIG_IsOK(ecode2)) {
33450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33451 }
33452 arg2 = static_cast< bool >(val2);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 wxWindow_SetDoubleBuffered(arg1,arg2);
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_Py_Void();
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33467 PyObject *resultobj = 0;
33468 wxWindow *arg1 = (wxWindow *) 0 ;
33469 long arg2 ;
33470 wxWindow *result = 0 ;
33471 void *argp1 = 0 ;
33472 int res1 = 0 ;
33473 long val2 ;
33474 int ecode2 = 0 ;
33475 PyObject * obj0 = 0 ;
33476 PyObject * obj1 = 0 ;
33477 char * kwnames[] = {
33478 (char *) "self",(char *) "winid", NULL
33479 };
33480
33481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33483 if (!SWIG_IsOK(res1)) {
33484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33485 }
33486 arg1 = reinterpret_cast< wxWindow * >(argp1);
33487 ecode2 = SWIG_AsVal_long(obj1, &val2);
33488 if (!SWIG_IsOK(ecode2)) {
33489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33490 }
33491 arg2 = static_cast< long >(val2);
33492 {
33493 PyThreadState* __tstate = wxPyBeginAllowThreads();
33494 result = (wxWindow *)(arg1)->FindWindow(arg2);
33495 wxPyEndAllowThreads(__tstate);
33496 if (PyErr_Occurred()) SWIG_fail;
33497 }
33498 {
33499 resultobj = wxPyMake_wxObject(result, 0);
33500 }
33501 return resultobj;
33502 fail:
33503 return NULL;
33504 }
33505
33506
33507 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33508 PyObject *resultobj = 0;
33509 wxWindow *arg1 = (wxWindow *) 0 ;
33510 wxString *arg2 = 0 ;
33511 wxWindow *result = 0 ;
33512 void *argp1 = 0 ;
33513 int res1 = 0 ;
33514 bool temp2 = false ;
33515 PyObject * obj0 = 0 ;
33516 PyObject * obj1 = 0 ;
33517 char * kwnames[] = {
33518 (char *) "self",(char *) "name", NULL
33519 };
33520
33521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33523 if (!SWIG_IsOK(res1)) {
33524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33525 }
33526 arg1 = reinterpret_cast< wxWindow * >(argp1);
33527 {
33528 arg2 = wxString_in_helper(obj1);
33529 if (arg2 == NULL) SWIG_fail;
33530 temp2 = true;
33531 }
33532 {
33533 PyThreadState* __tstate = wxPyBeginAllowThreads();
33534 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 {
33539 resultobj = wxPyMake_wxObject(result, 0);
33540 }
33541 {
33542 if (temp2)
33543 delete arg2;
33544 }
33545 return resultobj;
33546 fail:
33547 {
33548 if (temp2)
33549 delete arg2;
33550 }
33551 return NULL;
33552 }
33553
33554
33555 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33556 PyObject *resultobj = 0;
33557 wxWindow *arg1 = (wxWindow *) 0 ;
33558 wxEvtHandler *result = 0 ;
33559 void *argp1 = 0 ;
33560 int res1 = 0 ;
33561 PyObject *swig_obj[1] ;
33562
33563 if (!args) SWIG_fail;
33564 swig_obj[0] = args;
33565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33566 if (!SWIG_IsOK(res1)) {
33567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33568 }
33569 arg1 = reinterpret_cast< wxWindow * >(argp1);
33570 {
33571 PyThreadState* __tstate = wxPyBeginAllowThreads();
33572 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33573 wxPyEndAllowThreads(__tstate);
33574 if (PyErr_Occurred()) SWIG_fail;
33575 }
33576 {
33577 resultobj = wxPyMake_wxObject(result, 0);
33578 }
33579 return resultobj;
33580 fail:
33581 return NULL;
33582 }
33583
33584
33585 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33586 PyObject *resultobj = 0;
33587 wxWindow *arg1 = (wxWindow *) 0 ;
33588 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33589 void *argp1 = 0 ;
33590 int res1 = 0 ;
33591 void *argp2 = 0 ;
33592 int res2 = 0 ;
33593 PyObject * obj0 = 0 ;
33594 PyObject * obj1 = 0 ;
33595 char * kwnames[] = {
33596 (char *) "self",(char *) "handler", NULL
33597 };
33598
33599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33601 if (!SWIG_IsOK(res1)) {
33602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33603 }
33604 arg1 = reinterpret_cast< wxWindow * >(argp1);
33605 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33606 if (!SWIG_IsOK(res2)) {
33607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33608 }
33609 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33610 {
33611 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 (arg1)->SetEventHandler(arg2);
33613 wxPyEndAllowThreads(__tstate);
33614 if (PyErr_Occurred()) SWIG_fail;
33615 }
33616 resultobj = SWIG_Py_Void();
33617 return resultobj;
33618 fail:
33619 return NULL;
33620 }
33621
33622
33623 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33624 PyObject *resultobj = 0;
33625 wxWindow *arg1 = (wxWindow *) 0 ;
33626 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33627 void *argp1 = 0 ;
33628 int res1 = 0 ;
33629 void *argp2 = 0 ;
33630 int res2 = 0 ;
33631 PyObject * obj0 = 0 ;
33632 PyObject * obj1 = 0 ;
33633 char * kwnames[] = {
33634 (char *) "self",(char *) "handler", NULL
33635 };
33636
33637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33639 if (!SWIG_IsOK(res1)) {
33640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33641 }
33642 arg1 = reinterpret_cast< wxWindow * >(argp1);
33643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33644 if (!SWIG_IsOK(res2)) {
33645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33646 }
33647 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33648 {
33649 PyThreadState* __tstate = wxPyBeginAllowThreads();
33650 (arg1)->PushEventHandler(arg2);
33651 wxPyEndAllowThreads(__tstate);
33652 if (PyErr_Occurred()) SWIG_fail;
33653 }
33654 resultobj = SWIG_Py_Void();
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33662 PyObject *resultobj = 0;
33663 wxWindow *arg1 = (wxWindow *) 0 ;
33664 bool arg2 = (bool) false ;
33665 wxEvtHandler *result = 0 ;
33666 void *argp1 = 0 ;
33667 int res1 = 0 ;
33668 bool val2 ;
33669 int ecode2 = 0 ;
33670 PyObject * obj0 = 0 ;
33671 PyObject * obj1 = 0 ;
33672 char * kwnames[] = {
33673 (char *) "self",(char *) "deleteHandler", NULL
33674 };
33675
33676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33678 if (!SWIG_IsOK(res1)) {
33679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33680 }
33681 arg1 = reinterpret_cast< wxWindow * >(argp1);
33682 if (obj1) {
33683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33684 if (!SWIG_IsOK(ecode2)) {
33685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33686 }
33687 arg2 = static_cast< bool >(val2);
33688 }
33689 {
33690 PyThreadState* __tstate = wxPyBeginAllowThreads();
33691 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 {
33696 resultobj = wxPyMake_wxObject(result, 0);
33697 }
33698 return resultobj;
33699 fail:
33700 return NULL;
33701 }
33702
33703
33704 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33705 PyObject *resultobj = 0;
33706 wxWindow *arg1 = (wxWindow *) 0 ;
33707 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33708 bool result;
33709 void *argp1 = 0 ;
33710 int res1 = 0 ;
33711 void *argp2 = 0 ;
33712 int res2 = 0 ;
33713 PyObject * obj0 = 0 ;
33714 PyObject * obj1 = 0 ;
33715 char * kwnames[] = {
33716 (char *) "self",(char *) "handler", NULL
33717 };
33718
33719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33721 if (!SWIG_IsOK(res1)) {
33722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33723 }
33724 arg1 = reinterpret_cast< wxWindow * >(argp1);
33725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33726 if (!SWIG_IsOK(res2)) {
33727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33728 }
33729 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33730 {
33731 PyThreadState* __tstate = wxPyBeginAllowThreads();
33732 result = (bool)(arg1)->RemoveEventHandler(arg2);
33733 wxPyEndAllowThreads(__tstate);
33734 if (PyErr_Occurred()) SWIG_fail;
33735 }
33736 {
33737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33738 }
33739 return resultobj;
33740 fail:
33741 return NULL;
33742 }
33743
33744
33745 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33746 PyObject *resultobj = 0;
33747 wxWindow *arg1 = (wxWindow *) 0 ;
33748 wxValidator *arg2 = 0 ;
33749 void *argp1 = 0 ;
33750 int res1 = 0 ;
33751 void *argp2 = 0 ;
33752 int res2 = 0 ;
33753 PyObject * obj0 = 0 ;
33754 PyObject * obj1 = 0 ;
33755 char * kwnames[] = {
33756 (char *) "self",(char *) "validator", NULL
33757 };
33758
33759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33761 if (!SWIG_IsOK(res1)) {
33762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33763 }
33764 arg1 = reinterpret_cast< wxWindow * >(argp1);
33765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33766 if (!SWIG_IsOK(res2)) {
33767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33768 }
33769 if (!argp2) {
33770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33771 }
33772 arg2 = reinterpret_cast< wxValidator * >(argp2);
33773 {
33774 PyThreadState* __tstate = wxPyBeginAllowThreads();
33775 (arg1)->SetValidator((wxValidator const &)*arg2);
33776 wxPyEndAllowThreads(__tstate);
33777 if (PyErr_Occurred()) SWIG_fail;
33778 }
33779 resultobj = SWIG_Py_Void();
33780 return resultobj;
33781 fail:
33782 return NULL;
33783 }
33784
33785
33786 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33787 PyObject *resultobj = 0;
33788 wxWindow *arg1 = (wxWindow *) 0 ;
33789 wxValidator *result = 0 ;
33790 void *argp1 = 0 ;
33791 int res1 = 0 ;
33792 PyObject *swig_obj[1] ;
33793
33794 if (!args) SWIG_fail;
33795 swig_obj[0] = args;
33796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33797 if (!SWIG_IsOK(res1)) {
33798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33799 }
33800 arg1 = reinterpret_cast< wxWindow * >(argp1);
33801 {
33802 PyThreadState* __tstate = wxPyBeginAllowThreads();
33803 result = (wxValidator *)(arg1)->GetValidator();
33804 wxPyEndAllowThreads(__tstate);
33805 if (PyErr_Occurred()) SWIG_fail;
33806 }
33807 {
33808 resultobj = wxPyMake_wxObject(result, (bool)0);
33809 }
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 bool result;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 PyObject *swig_obj[1] ;
33823
33824 if (!args) SWIG_fail;
33825 swig_obj[0] = args;
33826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33827 if (!SWIG_IsOK(res1)) {
33828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33829 }
33830 arg1 = reinterpret_cast< wxWindow * >(argp1);
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 result = (bool)(arg1)->Validate();
33834 wxPyEndAllowThreads(__tstate);
33835 if (PyErr_Occurred()) SWIG_fail;
33836 }
33837 {
33838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33839 }
33840 return resultobj;
33841 fail:
33842 return NULL;
33843 }
33844
33845
33846 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33847 PyObject *resultobj = 0;
33848 wxWindow *arg1 = (wxWindow *) 0 ;
33849 bool result;
33850 void *argp1 = 0 ;
33851 int res1 = 0 ;
33852 PyObject *swig_obj[1] ;
33853
33854 if (!args) SWIG_fail;
33855 swig_obj[0] = args;
33856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33857 if (!SWIG_IsOK(res1)) {
33858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33859 }
33860 arg1 = reinterpret_cast< wxWindow * >(argp1);
33861 {
33862 PyThreadState* __tstate = wxPyBeginAllowThreads();
33863 result = (bool)(arg1)->TransferDataToWindow();
33864 wxPyEndAllowThreads(__tstate);
33865 if (PyErr_Occurred()) SWIG_fail;
33866 }
33867 {
33868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33869 }
33870 return resultobj;
33871 fail:
33872 return NULL;
33873 }
33874
33875
33876 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33877 PyObject *resultobj = 0;
33878 wxWindow *arg1 = (wxWindow *) 0 ;
33879 bool result;
33880 void *argp1 = 0 ;
33881 int res1 = 0 ;
33882 PyObject *swig_obj[1] ;
33883
33884 if (!args) SWIG_fail;
33885 swig_obj[0] = args;
33886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33887 if (!SWIG_IsOK(res1)) {
33888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33889 }
33890 arg1 = reinterpret_cast< wxWindow * >(argp1);
33891 {
33892 PyThreadState* __tstate = wxPyBeginAllowThreads();
33893 result = (bool)(arg1)->TransferDataFromWindow();
33894 wxPyEndAllowThreads(__tstate);
33895 if (PyErr_Occurred()) SWIG_fail;
33896 }
33897 {
33898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33899 }
33900 return resultobj;
33901 fail:
33902 return NULL;
33903 }
33904
33905
33906 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33907 PyObject *resultobj = 0;
33908 wxWindow *arg1 = (wxWindow *) 0 ;
33909 void *argp1 = 0 ;
33910 int res1 = 0 ;
33911 PyObject *swig_obj[1] ;
33912
33913 if (!args) SWIG_fail;
33914 swig_obj[0] = args;
33915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33916 if (!SWIG_IsOK(res1)) {
33917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33918 }
33919 arg1 = reinterpret_cast< wxWindow * >(argp1);
33920 {
33921 PyThreadState* __tstate = wxPyBeginAllowThreads();
33922 (arg1)->InitDialog();
33923 wxPyEndAllowThreads(__tstate);
33924 if (PyErr_Occurred()) SWIG_fail;
33925 }
33926 resultobj = SWIG_Py_Void();
33927 return resultobj;
33928 fail:
33929 return NULL;
33930 }
33931
33932
33933 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33934 PyObject *resultobj = 0;
33935 wxWindow *arg1 = (wxWindow *) 0 ;
33936 wxAcceleratorTable *arg2 = 0 ;
33937 void *argp1 = 0 ;
33938 int res1 = 0 ;
33939 void *argp2 = 0 ;
33940 int res2 = 0 ;
33941 PyObject * obj0 = 0 ;
33942 PyObject * obj1 = 0 ;
33943 char * kwnames[] = {
33944 (char *) "self",(char *) "accel", NULL
33945 };
33946
33947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33949 if (!SWIG_IsOK(res1)) {
33950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33951 }
33952 arg1 = reinterpret_cast< wxWindow * >(argp1);
33953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33954 if (!SWIG_IsOK(res2)) {
33955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33956 }
33957 if (!argp2) {
33958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33959 }
33960 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33961 {
33962 PyThreadState* __tstate = wxPyBeginAllowThreads();
33963 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33964 wxPyEndAllowThreads(__tstate);
33965 if (PyErr_Occurred()) SWIG_fail;
33966 }
33967 resultobj = SWIG_Py_Void();
33968 return resultobj;
33969 fail:
33970 return NULL;
33971 }
33972
33973
33974 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33975 PyObject *resultobj = 0;
33976 wxWindow *arg1 = (wxWindow *) 0 ;
33977 wxAcceleratorTable *result = 0 ;
33978 void *argp1 = 0 ;
33979 int res1 = 0 ;
33980 PyObject *swig_obj[1] ;
33981
33982 if (!args) SWIG_fail;
33983 swig_obj[0] = args;
33984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33985 if (!SWIG_IsOK(res1)) {
33986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33987 }
33988 arg1 = reinterpret_cast< wxWindow * >(argp1);
33989 {
33990 PyThreadState* __tstate = wxPyBeginAllowThreads();
33991 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33996 return resultobj;
33997 fail:
33998 return NULL;
33999 }
34000
34001
34002 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34003 PyObject *resultobj = 0;
34004 wxWindow *arg1 = (wxWindow *) 0 ;
34005 int arg2 ;
34006 int arg3 ;
34007 int arg4 ;
34008 bool result;
34009 void *argp1 = 0 ;
34010 int res1 = 0 ;
34011 int val2 ;
34012 int ecode2 = 0 ;
34013 int val3 ;
34014 int ecode3 = 0 ;
34015 int val4 ;
34016 int ecode4 = 0 ;
34017 PyObject * obj0 = 0 ;
34018 PyObject * obj1 = 0 ;
34019 PyObject * obj2 = 0 ;
34020 PyObject * obj3 = 0 ;
34021 char * kwnames[] = {
34022 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34023 };
34024
34025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34027 if (!SWIG_IsOK(res1)) {
34028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34029 }
34030 arg1 = reinterpret_cast< wxWindow * >(argp1);
34031 ecode2 = SWIG_AsVal_int(obj1, &val2);
34032 if (!SWIG_IsOK(ecode2)) {
34033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34034 }
34035 arg2 = static_cast< int >(val2);
34036 ecode3 = SWIG_AsVal_int(obj2, &val3);
34037 if (!SWIG_IsOK(ecode3)) {
34038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34039 }
34040 arg3 = static_cast< int >(val3);
34041 ecode4 = SWIG_AsVal_int(obj3, &val4);
34042 if (!SWIG_IsOK(ecode4)) {
34043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34044 }
34045 arg4 = static_cast< int >(val4);
34046 {
34047 PyThreadState* __tstate = wxPyBeginAllowThreads();
34048 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34049 wxPyEndAllowThreads(__tstate);
34050 if (PyErr_Occurred()) SWIG_fail;
34051 }
34052 {
34053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34054 }
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34062 PyObject *resultobj = 0;
34063 wxWindow *arg1 = (wxWindow *) 0 ;
34064 int arg2 ;
34065 bool result;
34066 void *argp1 = 0 ;
34067 int res1 = 0 ;
34068 int val2 ;
34069 int ecode2 = 0 ;
34070 PyObject * obj0 = 0 ;
34071 PyObject * obj1 = 0 ;
34072 char * kwnames[] = {
34073 (char *) "self",(char *) "hotkeyId", NULL
34074 };
34075
34076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34078 if (!SWIG_IsOK(res1)) {
34079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34080 }
34081 arg1 = reinterpret_cast< wxWindow * >(argp1);
34082 ecode2 = SWIG_AsVal_int(obj1, &val2);
34083 if (!SWIG_IsOK(ecode2)) {
34084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34085 }
34086 arg2 = static_cast< int >(val2);
34087 {
34088 PyThreadState* __tstate = wxPyBeginAllowThreads();
34089 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 {
34094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34095 }
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34103 PyObject *resultobj = 0;
34104 wxWindow *arg1 = (wxWindow *) 0 ;
34105 wxPoint *arg2 = 0 ;
34106 wxPoint result;
34107 void *argp1 = 0 ;
34108 int res1 = 0 ;
34109 wxPoint temp2 ;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 char * kwnames[] = {
34113 (char *) "self",(char *) "pt", NULL
34114 };
34115
34116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34120 }
34121 arg1 = reinterpret_cast< wxWindow * >(argp1);
34122 {
34123 arg2 = &temp2;
34124 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34125 }
34126 {
34127 PyThreadState* __tstate = wxPyBeginAllowThreads();
34128 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34133 return resultobj;
34134 fail:
34135 return NULL;
34136 }
34137
34138
34139 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34140 PyObject *resultobj = 0;
34141 wxWindow *arg1 = (wxWindow *) 0 ;
34142 wxSize *arg2 = 0 ;
34143 wxSize result;
34144 void *argp1 = 0 ;
34145 int res1 = 0 ;
34146 wxSize temp2 ;
34147 PyObject * obj0 = 0 ;
34148 PyObject * obj1 = 0 ;
34149 char * kwnames[] = {
34150 (char *) "self",(char *) "sz", NULL
34151 };
34152
34153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34155 if (!SWIG_IsOK(res1)) {
34156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34157 }
34158 arg1 = reinterpret_cast< wxWindow * >(argp1);
34159 {
34160 arg2 = &temp2;
34161 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34162 }
34163 {
34164 PyThreadState* __tstate = wxPyBeginAllowThreads();
34165 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34166 wxPyEndAllowThreads(__tstate);
34167 if (PyErr_Occurred()) SWIG_fail;
34168 }
34169 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34170 return resultobj;
34171 fail:
34172 return NULL;
34173 }
34174
34175
34176 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34177 PyObject *resultobj = 0;
34178 wxWindow *arg1 = (wxWindow *) 0 ;
34179 wxPoint *arg2 = 0 ;
34180 wxPoint result;
34181 void *argp1 = 0 ;
34182 int res1 = 0 ;
34183 wxPoint temp2 ;
34184 PyObject * obj0 = 0 ;
34185 PyObject * obj1 = 0 ;
34186 char * kwnames[] = {
34187 (char *) "self",(char *) "pt", NULL
34188 };
34189
34190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34192 if (!SWIG_IsOK(res1)) {
34193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34194 }
34195 arg1 = reinterpret_cast< wxWindow * >(argp1);
34196 {
34197 arg2 = &temp2;
34198 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34199 }
34200 {
34201 PyThreadState* __tstate = wxPyBeginAllowThreads();
34202 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34203 wxPyEndAllowThreads(__tstate);
34204 if (PyErr_Occurred()) SWIG_fail;
34205 }
34206 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34207 return resultobj;
34208 fail:
34209 return NULL;
34210 }
34211
34212
34213 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34214 PyObject *resultobj = 0;
34215 wxWindow *arg1 = (wxWindow *) 0 ;
34216 wxSize *arg2 = 0 ;
34217 wxSize result;
34218 void *argp1 = 0 ;
34219 int res1 = 0 ;
34220 wxSize temp2 ;
34221 PyObject * obj0 = 0 ;
34222 PyObject * obj1 = 0 ;
34223 char * kwnames[] = {
34224 (char *) "self",(char *) "sz", NULL
34225 };
34226
34227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34229 if (!SWIG_IsOK(res1)) {
34230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34231 }
34232 arg1 = reinterpret_cast< wxWindow * >(argp1);
34233 {
34234 arg2 = &temp2;
34235 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34236 }
34237 {
34238 PyThreadState* __tstate = wxPyBeginAllowThreads();
34239 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34240 wxPyEndAllowThreads(__tstate);
34241 if (PyErr_Occurred()) SWIG_fail;
34242 }
34243 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34244 return resultobj;
34245 fail:
34246 return NULL;
34247 }
34248
34249
34250 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34251 PyObject *resultobj = 0;
34252 wxWindow *arg1 = (wxWindow *) 0 ;
34253 wxPoint *arg2 = 0 ;
34254 wxPoint result;
34255 void *argp1 = 0 ;
34256 int res1 = 0 ;
34257 wxPoint temp2 ;
34258 PyObject * obj0 = 0 ;
34259 PyObject * obj1 = 0 ;
34260 char * kwnames[] = {
34261 (char *) "self",(char *) "pt", NULL
34262 };
34263
34264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34266 if (!SWIG_IsOK(res1)) {
34267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34268 }
34269 arg1 = reinterpret_cast< wxWindow * >(argp1);
34270 {
34271 arg2 = &temp2;
34272 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34273 }
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34288 PyObject *resultobj = 0;
34289 wxWindow *arg1 = (wxWindow *) 0 ;
34290 wxSize *arg2 = 0 ;
34291 wxSize result;
34292 void *argp1 = 0 ;
34293 int res1 = 0 ;
34294 wxSize temp2 ;
34295 PyObject * obj0 = 0 ;
34296 PyObject * obj1 = 0 ;
34297 char * kwnames[] = {
34298 (char *) "self",(char *) "sz", NULL
34299 };
34300
34301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34303 if (!SWIG_IsOK(res1)) {
34304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34305 }
34306 arg1 = reinterpret_cast< wxWindow * >(argp1);
34307 {
34308 arg2 = &temp2;
34309 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34310 }
34311 {
34312 PyThreadState* __tstate = wxPyBeginAllowThreads();
34313 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34318 return resultobj;
34319 fail:
34320 return NULL;
34321 }
34322
34323
34324 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34325 PyObject *resultobj = 0;
34326 wxWindow *arg1 = (wxWindow *) 0 ;
34327 int arg2 ;
34328 int arg3 ;
34329 void *argp1 = 0 ;
34330 int res1 = 0 ;
34331 int val2 ;
34332 int ecode2 = 0 ;
34333 int val3 ;
34334 int ecode3 = 0 ;
34335 PyObject * obj0 = 0 ;
34336 PyObject * obj1 = 0 ;
34337 PyObject * obj2 = 0 ;
34338 char * kwnames[] = {
34339 (char *) "self",(char *) "x",(char *) "y", NULL
34340 };
34341
34342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34346 }
34347 arg1 = reinterpret_cast< wxWindow * >(argp1);
34348 ecode2 = SWIG_AsVal_int(obj1, &val2);
34349 if (!SWIG_IsOK(ecode2)) {
34350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34351 }
34352 arg2 = static_cast< int >(val2);
34353 ecode3 = SWIG_AsVal_int(obj2, &val3);
34354 if (!SWIG_IsOK(ecode3)) {
34355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34356 }
34357 arg3 = static_cast< int >(val3);
34358 {
34359 PyThreadState* __tstate = wxPyBeginAllowThreads();
34360 (arg1)->WarpPointer(arg2,arg3);
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 resultobj = SWIG_Py_Void();
34365 return resultobj;
34366 fail:
34367 return NULL;
34368 }
34369
34370
34371 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34372 PyObject *resultobj = 0;
34373 wxWindow *arg1 = (wxWindow *) 0 ;
34374 void *argp1 = 0 ;
34375 int res1 = 0 ;
34376 PyObject *swig_obj[1] ;
34377
34378 if (!args) SWIG_fail;
34379 swig_obj[0] = args;
34380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34381 if (!SWIG_IsOK(res1)) {
34382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34383 }
34384 arg1 = reinterpret_cast< wxWindow * >(argp1);
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 (arg1)->CaptureMouse();
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 resultobj = SWIG_Py_Void();
34392 return resultobj;
34393 fail:
34394 return NULL;
34395 }
34396
34397
34398 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34399 PyObject *resultobj = 0;
34400 wxWindow *arg1 = (wxWindow *) 0 ;
34401 void *argp1 = 0 ;
34402 int res1 = 0 ;
34403 PyObject *swig_obj[1] ;
34404
34405 if (!args) SWIG_fail;
34406 swig_obj[0] = args;
34407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34408 if (!SWIG_IsOK(res1)) {
34409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34410 }
34411 arg1 = reinterpret_cast< wxWindow * >(argp1);
34412 {
34413 PyThreadState* __tstate = wxPyBeginAllowThreads();
34414 (arg1)->ReleaseMouse();
34415 wxPyEndAllowThreads(__tstate);
34416 if (PyErr_Occurred()) SWIG_fail;
34417 }
34418 resultobj = SWIG_Py_Void();
34419 return resultobj;
34420 fail:
34421 return NULL;
34422 }
34423
34424
34425 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34426 PyObject *resultobj = 0;
34427 wxWindow *result = 0 ;
34428
34429 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34430 {
34431 if (!wxPyCheckForApp()) SWIG_fail;
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = (wxWindow *)wxWindow::GetCapture();
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 {
34438 resultobj = wxPyMake_wxObject(result, 0);
34439 }
34440 return resultobj;
34441 fail:
34442 return NULL;
34443 }
34444
34445
34446 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34447 PyObject *resultobj = 0;
34448 wxWindow *arg1 = (wxWindow *) 0 ;
34449 bool result;
34450 void *argp1 = 0 ;
34451 int res1 = 0 ;
34452 PyObject *swig_obj[1] ;
34453
34454 if (!args) SWIG_fail;
34455 swig_obj[0] = args;
34456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34457 if (!SWIG_IsOK(res1)) {
34458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34459 }
34460 arg1 = reinterpret_cast< wxWindow * >(argp1);
34461 {
34462 PyThreadState* __tstate = wxPyBeginAllowThreads();
34463 result = (bool)((wxWindow const *)arg1)->HasCapture();
34464 wxPyEndAllowThreads(__tstate);
34465 if (PyErr_Occurred()) SWIG_fail;
34466 }
34467 {
34468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34469 }
34470 return resultobj;
34471 fail:
34472 return NULL;
34473 }
34474
34475
34476 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34477 PyObject *resultobj = 0;
34478 wxWindow *arg1 = (wxWindow *) 0 ;
34479 bool arg2 = (bool) true ;
34480 wxRect *arg3 = (wxRect *) NULL ;
34481 void *argp1 = 0 ;
34482 int res1 = 0 ;
34483 bool val2 ;
34484 int ecode2 = 0 ;
34485 void *argp3 = 0 ;
34486 int res3 = 0 ;
34487 PyObject * obj0 = 0 ;
34488 PyObject * obj1 = 0 ;
34489 PyObject * obj2 = 0 ;
34490 char * kwnames[] = {
34491 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34492 };
34493
34494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34496 if (!SWIG_IsOK(res1)) {
34497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34498 }
34499 arg1 = reinterpret_cast< wxWindow * >(argp1);
34500 if (obj1) {
34501 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34502 if (!SWIG_IsOK(ecode2)) {
34503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34504 }
34505 arg2 = static_cast< bool >(val2);
34506 }
34507 if (obj2) {
34508 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34509 if (!SWIG_IsOK(res3)) {
34510 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34511 }
34512 arg3 = reinterpret_cast< wxRect * >(argp3);
34513 }
34514 {
34515 PyThreadState* __tstate = wxPyBeginAllowThreads();
34516 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34517 wxPyEndAllowThreads(__tstate);
34518 if (PyErr_Occurred()) SWIG_fail;
34519 }
34520 resultobj = SWIG_Py_Void();
34521 return resultobj;
34522 fail:
34523 return NULL;
34524 }
34525
34526
34527 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34528 PyObject *resultobj = 0;
34529 wxWindow *arg1 = (wxWindow *) 0 ;
34530 wxRect *arg2 = 0 ;
34531 bool arg3 = (bool) true ;
34532 void *argp1 = 0 ;
34533 int res1 = 0 ;
34534 wxRect temp2 ;
34535 bool val3 ;
34536 int ecode3 = 0 ;
34537 PyObject * obj0 = 0 ;
34538 PyObject * obj1 = 0 ;
34539 PyObject * obj2 = 0 ;
34540 char * kwnames[] = {
34541 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34542 };
34543
34544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34546 if (!SWIG_IsOK(res1)) {
34547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34548 }
34549 arg1 = reinterpret_cast< wxWindow * >(argp1);
34550 {
34551 arg2 = &temp2;
34552 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34553 }
34554 if (obj2) {
34555 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34556 if (!SWIG_IsOK(ecode3)) {
34557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34558 }
34559 arg3 = static_cast< bool >(val3);
34560 }
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 resultobj = SWIG_Py_Void();
34568 return resultobj;
34569 fail:
34570 return NULL;
34571 }
34572
34573
34574 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34575 PyObject *resultobj = 0;
34576 wxWindow *arg1 = (wxWindow *) 0 ;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 PyObject *swig_obj[1] ;
34580
34581 if (!args) SWIG_fail;
34582 swig_obj[0] = args;
34583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34584 if (!SWIG_IsOK(res1)) {
34585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34586 }
34587 arg1 = reinterpret_cast< wxWindow * >(argp1);
34588 {
34589 PyThreadState* __tstate = wxPyBeginAllowThreads();
34590 (arg1)->Update();
34591 wxPyEndAllowThreads(__tstate);
34592 if (PyErr_Occurred()) SWIG_fail;
34593 }
34594 resultobj = SWIG_Py_Void();
34595 return resultobj;
34596 fail:
34597 return NULL;
34598 }
34599
34600
34601 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34602 PyObject *resultobj = 0;
34603 wxWindow *arg1 = (wxWindow *) 0 ;
34604 void *argp1 = 0 ;
34605 int res1 = 0 ;
34606 PyObject *swig_obj[1] ;
34607
34608 if (!args) SWIG_fail;
34609 swig_obj[0] = args;
34610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34611 if (!SWIG_IsOK(res1)) {
34612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34613 }
34614 arg1 = reinterpret_cast< wxWindow * >(argp1);
34615 {
34616 PyThreadState* __tstate = wxPyBeginAllowThreads();
34617 (arg1)->ClearBackground();
34618 wxPyEndAllowThreads(__tstate);
34619 if (PyErr_Occurred()) SWIG_fail;
34620 }
34621 resultobj = SWIG_Py_Void();
34622 return resultobj;
34623 fail:
34624 return NULL;
34625 }
34626
34627
34628 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34629 PyObject *resultobj = 0;
34630 wxWindow *arg1 = (wxWindow *) 0 ;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 PyObject *swig_obj[1] ;
34634
34635 if (!args) SWIG_fail;
34636 swig_obj[0] = args;
34637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34638 if (!SWIG_IsOK(res1)) {
34639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34640 }
34641 arg1 = reinterpret_cast< wxWindow * >(argp1);
34642 {
34643 PyThreadState* __tstate = wxPyBeginAllowThreads();
34644 (arg1)->Freeze();
34645 wxPyEndAllowThreads(__tstate);
34646 if (PyErr_Occurred()) SWIG_fail;
34647 }
34648 resultobj = SWIG_Py_Void();
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34656 PyObject *resultobj = 0;
34657 wxWindow *arg1 = (wxWindow *) 0 ;
34658 void *argp1 = 0 ;
34659 int res1 = 0 ;
34660 PyObject *swig_obj[1] ;
34661
34662 if (!args) SWIG_fail;
34663 swig_obj[0] = args;
34664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34665 if (!SWIG_IsOK(res1)) {
34666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34667 }
34668 arg1 = reinterpret_cast< wxWindow * >(argp1);
34669 {
34670 PyThreadState* __tstate = wxPyBeginAllowThreads();
34671 (arg1)->Thaw();
34672 wxPyEndAllowThreads(__tstate);
34673 if (PyErr_Occurred()) SWIG_fail;
34674 }
34675 resultobj = SWIG_Py_Void();
34676 return resultobj;
34677 fail:
34678 return NULL;
34679 }
34680
34681
34682 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34683 PyObject *resultobj = 0;
34684 wxWindow *arg1 = (wxWindow *) 0 ;
34685 wxDC *arg2 = 0 ;
34686 void *argp1 = 0 ;
34687 int res1 = 0 ;
34688 void *argp2 = 0 ;
34689 int res2 = 0 ;
34690 PyObject * obj0 = 0 ;
34691 PyObject * obj1 = 0 ;
34692 char * kwnames[] = {
34693 (char *) "self",(char *) "dc", NULL
34694 };
34695
34696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34698 if (!SWIG_IsOK(res1)) {
34699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34700 }
34701 arg1 = reinterpret_cast< wxWindow * >(argp1);
34702 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34703 if (!SWIG_IsOK(res2)) {
34704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34705 }
34706 if (!argp2) {
34707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34708 }
34709 arg2 = reinterpret_cast< wxDC * >(argp2);
34710 {
34711 PyThreadState* __tstate = wxPyBeginAllowThreads();
34712 (arg1)->PrepareDC(*arg2);
34713 wxPyEndAllowThreads(__tstate);
34714 if (PyErr_Occurred()) SWIG_fail;
34715 }
34716 resultobj = SWIG_Py_Void();
34717 return resultobj;
34718 fail:
34719 return NULL;
34720 }
34721
34722
34723 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34724 PyObject *resultobj = 0;
34725 wxWindow *arg1 = (wxWindow *) 0 ;
34726 wxRegion *result = 0 ;
34727 void *argp1 = 0 ;
34728 int res1 = 0 ;
34729 PyObject *swig_obj[1] ;
34730
34731 if (!args) SWIG_fail;
34732 swig_obj[0] = args;
34733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34734 if (!SWIG_IsOK(res1)) {
34735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34736 }
34737 arg1 = reinterpret_cast< wxWindow * >(argp1);
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 {
34741 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34742 result = (wxRegion *) &_result_ref;
34743 }
34744 wxPyEndAllowThreads(__tstate);
34745 if (PyErr_Occurred()) SWIG_fail;
34746 }
34747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34748 return resultobj;
34749 fail:
34750 return NULL;
34751 }
34752
34753
34754 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34755 PyObject *resultobj = 0;
34756 wxWindow *arg1 = (wxWindow *) 0 ;
34757 wxRect result;
34758 void *argp1 = 0 ;
34759 int res1 = 0 ;
34760 PyObject *swig_obj[1] ;
34761
34762 if (!args) SWIG_fail;
34763 swig_obj[0] = args;
34764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34767 }
34768 arg1 = reinterpret_cast< wxWindow * >(argp1);
34769 {
34770 PyThreadState* __tstate = wxPyBeginAllowThreads();
34771 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34776 return resultobj;
34777 fail:
34778 return NULL;
34779 }
34780
34781
34782 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34783 PyObject *resultobj = 0;
34784 wxWindow *arg1 = (wxWindow *) 0 ;
34785 int arg2 ;
34786 int arg3 ;
34787 int arg4 = (int) 1 ;
34788 int arg5 = (int) 1 ;
34789 bool result;
34790 void *argp1 = 0 ;
34791 int res1 = 0 ;
34792 int val2 ;
34793 int ecode2 = 0 ;
34794 int val3 ;
34795 int ecode3 = 0 ;
34796 int val4 ;
34797 int ecode4 = 0 ;
34798 int val5 ;
34799 int ecode5 = 0 ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 PyObject * obj2 = 0 ;
34803 PyObject * obj3 = 0 ;
34804 PyObject * obj4 = 0 ;
34805 char * kwnames[] = {
34806 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34807 };
34808
34809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34811 if (!SWIG_IsOK(res1)) {
34812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34813 }
34814 arg1 = reinterpret_cast< wxWindow * >(argp1);
34815 ecode2 = SWIG_AsVal_int(obj1, &val2);
34816 if (!SWIG_IsOK(ecode2)) {
34817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34818 }
34819 arg2 = static_cast< int >(val2);
34820 ecode3 = SWIG_AsVal_int(obj2, &val3);
34821 if (!SWIG_IsOK(ecode3)) {
34822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34823 }
34824 arg3 = static_cast< int >(val3);
34825 if (obj3) {
34826 ecode4 = SWIG_AsVal_int(obj3, &val4);
34827 if (!SWIG_IsOK(ecode4)) {
34828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34829 }
34830 arg4 = static_cast< int >(val4);
34831 }
34832 if (obj4) {
34833 ecode5 = SWIG_AsVal_int(obj4, &val5);
34834 if (!SWIG_IsOK(ecode5)) {
34835 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34836 }
34837 arg5 = static_cast< int >(val5);
34838 }
34839 {
34840 PyThreadState* __tstate = wxPyBeginAllowThreads();
34841 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 {
34846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34847 }
34848 return resultobj;
34849 fail:
34850 return NULL;
34851 }
34852
34853
34854 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34855 PyObject *resultobj = 0;
34856 wxWindow *arg1 = (wxWindow *) 0 ;
34857 wxPoint *arg2 = 0 ;
34858 bool result;
34859 void *argp1 = 0 ;
34860 int res1 = 0 ;
34861 wxPoint temp2 ;
34862 PyObject * obj0 = 0 ;
34863 PyObject * obj1 = 0 ;
34864 char * kwnames[] = {
34865 (char *) "self",(char *) "pt", NULL
34866 };
34867
34868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34870 if (!SWIG_IsOK(res1)) {
34871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34872 }
34873 arg1 = reinterpret_cast< wxWindow * >(argp1);
34874 {
34875 arg2 = &temp2;
34876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34877 }
34878 {
34879 PyThreadState* __tstate = wxPyBeginAllowThreads();
34880 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34881 wxPyEndAllowThreads(__tstate);
34882 if (PyErr_Occurred()) SWIG_fail;
34883 }
34884 {
34885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34886 }
34887 return resultobj;
34888 fail:
34889 return NULL;
34890 }
34891
34892
34893 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34894 PyObject *resultobj = 0;
34895 wxWindow *arg1 = (wxWindow *) 0 ;
34896 wxRect *arg2 = 0 ;
34897 bool result;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 wxRect temp2 ;
34901 PyObject * obj0 = 0 ;
34902 PyObject * obj1 = 0 ;
34903 char * kwnames[] = {
34904 (char *) "self",(char *) "rect", NULL
34905 };
34906
34907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34909 if (!SWIG_IsOK(res1)) {
34910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34911 }
34912 arg1 = reinterpret_cast< wxWindow * >(argp1);
34913 {
34914 arg2 = &temp2;
34915 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34916 }
34917 {
34918 PyThreadState* __tstate = wxPyBeginAllowThreads();
34919 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34920 wxPyEndAllowThreads(__tstate);
34921 if (PyErr_Occurred()) SWIG_fail;
34922 }
34923 {
34924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34925 }
34926 return resultobj;
34927 fail:
34928 return NULL;
34929 }
34930
34931
34932 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34933 PyObject *resultobj = 0;
34934 wxWindow *arg1 = (wxWindow *) 0 ;
34935 SwigValueWrapper<wxVisualAttributes > result;
34936 void *argp1 = 0 ;
34937 int res1 = 0 ;
34938 PyObject *swig_obj[1] ;
34939
34940 if (!args) SWIG_fail;
34941 swig_obj[0] = args;
34942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34943 if (!SWIG_IsOK(res1)) {
34944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34945 }
34946 arg1 = reinterpret_cast< wxWindow * >(argp1);
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34954 return resultobj;
34955 fail:
34956 return NULL;
34957 }
34958
34959
34960 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34961 PyObject *resultobj = 0;
34962 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34963 SwigValueWrapper<wxVisualAttributes > result;
34964 int val1 ;
34965 int ecode1 = 0 ;
34966 PyObject * obj0 = 0 ;
34967 char * kwnames[] = {
34968 (char *) "variant", NULL
34969 };
34970
34971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34972 if (obj0) {
34973 ecode1 = SWIG_AsVal_int(obj0, &val1);
34974 if (!SWIG_IsOK(ecode1)) {
34975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34976 }
34977 arg1 = static_cast< wxWindowVariant >(val1);
34978 }
34979 {
34980 if (!wxPyCheckForApp()) SWIG_fail;
34981 PyThreadState* __tstate = wxPyBeginAllowThreads();
34982 result = wxWindow::GetClassDefaultAttributes(arg1);
34983 wxPyEndAllowThreads(__tstate);
34984 if (PyErr_Occurred()) SWIG_fail;
34985 }
34986 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34994 PyObject *resultobj = 0;
34995 wxWindow *arg1 = (wxWindow *) 0 ;
34996 wxColour *arg2 = 0 ;
34997 bool result;
34998 void *argp1 = 0 ;
34999 int res1 = 0 ;
35000 wxColour temp2 ;
35001 PyObject * obj0 = 0 ;
35002 PyObject * obj1 = 0 ;
35003 char * kwnames[] = {
35004 (char *) "self",(char *) "colour", NULL
35005 };
35006
35007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35009 if (!SWIG_IsOK(res1)) {
35010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35011 }
35012 arg1 = reinterpret_cast< wxWindow * >(argp1);
35013 {
35014 arg2 = &temp2;
35015 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35016 }
35017 {
35018 PyThreadState* __tstate = wxPyBeginAllowThreads();
35019 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35020 wxPyEndAllowThreads(__tstate);
35021 if (PyErr_Occurred()) SWIG_fail;
35022 }
35023 {
35024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35025 }
35026 return resultobj;
35027 fail:
35028 return NULL;
35029 }
35030
35031
35032 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35033 PyObject *resultobj = 0;
35034 wxWindow *arg1 = (wxWindow *) 0 ;
35035 wxColour *arg2 = 0 ;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 wxColour temp2 ;
35039 PyObject * obj0 = 0 ;
35040 PyObject * obj1 = 0 ;
35041 char * kwnames[] = {
35042 (char *) "self",(char *) "colour", NULL
35043 };
35044
35045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35047 if (!SWIG_IsOK(res1)) {
35048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35049 }
35050 arg1 = reinterpret_cast< wxWindow * >(argp1);
35051 {
35052 arg2 = &temp2;
35053 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35054 }
35055 {
35056 PyThreadState* __tstate = wxPyBeginAllowThreads();
35057 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35058 wxPyEndAllowThreads(__tstate);
35059 if (PyErr_Occurred()) SWIG_fail;
35060 }
35061 resultobj = SWIG_Py_Void();
35062 return resultobj;
35063 fail:
35064 return NULL;
35065 }
35066
35067
35068 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35069 PyObject *resultobj = 0;
35070 wxWindow *arg1 = (wxWindow *) 0 ;
35071 wxColour *arg2 = 0 ;
35072 bool result;
35073 void *argp1 = 0 ;
35074 int res1 = 0 ;
35075 wxColour temp2 ;
35076 PyObject * obj0 = 0 ;
35077 PyObject * obj1 = 0 ;
35078 char * kwnames[] = {
35079 (char *) "self",(char *) "colour", NULL
35080 };
35081
35082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35084 if (!SWIG_IsOK(res1)) {
35085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35086 }
35087 arg1 = reinterpret_cast< wxWindow * >(argp1);
35088 {
35089 arg2 = &temp2;
35090 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35091 }
35092 {
35093 PyThreadState* __tstate = wxPyBeginAllowThreads();
35094 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35095 wxPyEndAllowThreads(__tstate);
35096 if (PyErr_Occurred()) SWIG_fail;
35097 }
35098 {
35099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35100 }
35101 return resultobj;
35102 fail:
35103 return NULL;
35104 }
35105
35106
35107 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35108 PyObject *resultobj = 0;
35109 wxWindow *arg1 = (wxWindow *) 0 ;
35110 wxColour *arg2 = 0 ;
35111 void *argp1 = 0 ;
35112 int res1 = 0 ;
35113 wxColour temp2 ;
35114 PyObject * obj0 = 0 ;
35115 PyObject * obj1 = 0 ;
35116 char * kwnames[] = {
35117 (char *) "self",(char *) "colour", NULL
35118 };
35119
35120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35122 if (!SWIG_IsOK(res1)) {
35123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35124 }
35125 arg1 = reinterpret_cast< wxWindow * >(argp1);
35126 {
35127 arg2 = &temp2;
35128 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35129 }
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35133 wxPyEndAllowThreads(__tstate);
35134 if (PyErr_Occurred()) SWIG_fail;
35135 }
35136 resultobj = SWIG_Py_Void();
35137 return resultobj;
35138 fail:
35139 return NULL;
35140 }
35141
35142
35143 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35144 PyObject *resultobj = 0;
35145 wxWindow *arg1 = (wxWindow *) 0 ;
35146 wxColour result;
35147 void *argp1 = 0 ;
35148 int res1 = 0 ;
35149 PyObject *swig_obj[1] ;
35150
35151 if (!args) SWIG_fail;
35152 swig_obj[0] = args;
35153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35154 if (!SWIG_IsOK(res1)) {
35155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35156 }
35157 arg1 = reinterpret_cast< wxWindow * >(argp1);
35158 {
35159 PyThreadState* __tstate = wxPyBeginAllowThreads();
35160 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35161 wxPyEndAllowThreads(__tstate);
35162 if (PyErr_Occurred()) SWIG_fail;
35163 }
35164 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35165 return resultobj;
35166 fail:
35167 return NULL;
35168 }
35169
35170
35171 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35172 PyObject *resultobj = 0;
35173 wxWindow *arg1 = (wxWindow *) 0 ;
35174 wxColour result;
35175 void *argp1 = 0 ;
35176 int res1 = 0 ;
35177 PyObject *swig_obj[1] ;
35178
35179 if (!args) SWIG_fail;
35180 swig_obj[0] = args;
35181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35184 }
35185 arg1 = reinterpret_cast< wxWindow * >(argp1);
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 result = ((wxWindow const *)arg1)->GetForegroundColour();
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 bool result;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 PyObject *swig_obj[1] ;
35206
35207 if (!args) SWIG_fail;
35208 swig_obj[0] = args;
35209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35210 if (!SWIG_IsOK(res1)) {
35211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35212 }
35213 arg1 = reinterpret_cast< wxWindow * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 {
35221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35222 }
35223 return resultobj;
35224 fail:
35225 return NULL;
35226 }
35227
35228
35229 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35230 PyObject *resultobj = 0;
35231 wxWindow *arg1 = (wxWindow *) 0 ;
35232 bool result;
35233 void *argp1 = 0 ;
35234 int res1 = 0 ;
35235 PyObject *swig_obj[1] ;
35236
35237 if (!args) SWIG_fail;
35238 swig_obj[0] = args;
35239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35240 if (!SWIG_IsOK(res1)) {
35241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35242 }
35243 arg1 = reinterpret_cast< wxWindow * >(argp1);
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 {
35251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35252 }
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxBackgroundStyle arg2 ;
35263 bool result;
35264 void *argp1 = 0 ;
35265 int res1 = 0 ;
35266 int val2 ;
35267 int ecode2 = 0 ;
35268 PyObject * obj0 = 0 ;
35269 PyObject * obj1 = 0 ;
35270 char * kwnames[] = {
35271 (char *) "self",(char *) "style", NULL
35272 };
35273
35274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35276 if (!SWIG_IsOK(res1)) {
35277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35278 }
35279 arg1 = reinterpret_cast< wxWindow * >(argp1);
35280 ecode2 = SWIG_AsVal_int(obj1, &val2);
35281 if (!SWIG_IsOK(ecode2)) {
35282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35283 }
35284 arg2 = static_cast< wxBackgroundStyle >(val2);
35285 {
35286 PyThreadState* __tstate = wxPyBeginAllowThreads();
35287 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35288 wxPyEndAllowThreads(__tstate);
35289 if (PyErr_Occurred()) SWIG_fail;
35290 }
35291 {
35292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35293 }
35294 return resultobj;
35295 fail:
35296 return NULL;
35297 }
35298
35299
35300 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35301 PyObject *resultobj = 0;
35302 wxWindow *arg1 = (wxWindow *) 0 ;
35303 wxBackgroundStyle result;
35304 void *argp1 = 0 ;
35305 int res1 = 0 ;
35306 PyObject *swig_obj[1] ;
35307
35308 if (!args) SWIG_fail;
35309 swig_obj[0] = args;
35310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35311 if (!SWIG_IsOK(res1)) {
35312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35313 }
35314 arg1 = reinterpret_cast< wxWindow * >(argp1);
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 resultobj = SWIG_From_int(static_cast< int >(result));
35322 return resultobj;
35323 fail:
35324 return NULL;
35325 }
35326
35327
35328 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35329 PyObject *resultobj = 0;
35330 wxWindow *arg1 = (wxWindow *) 0 ;
35331 bool result;
35332 void *argp1 = 0 ;
35333 int res1 = 0 ;
35334 PyObject *swig_obj[1] ;
35335
35336 if (!args) SWIG_fail;
35337 swig_obj[0] = args;
35338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35339 if (!SWIG_IsOK(res1)) {
35340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35341 }
35342 arg1 = reinterpret_cast< wxWindow * >(argp1);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 result = (bool)(arg1)->HasTransparentBackground();
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 {
35350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35351 }
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35359 PyObject *resultobj = 0;
35360 wxWindow *arg1 = (wxWindow *) 0 ;
35361 wxCursor *arg2 = 0 ;
35362 bool result;
35363 void *argp1 = 0 ;
35364 int res1 = 0 ;
35365 void *argp2 = 0 ;
35366 int res2 = 0 ;
35367 PyObject * obj0 = 0 ;
35368 PyObject * obj1 = 0 ;
35369 char * kwnames[] = {
35370 (char *) "self",(char *) "cursor", NULL
35371 };
35372
35373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35377 }
35378 arg1 = reinterpret_cast< wxWindow * >(argp1);
35379 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35380 if (!SWIG_IsOK(res2)) {
35381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35382 }
35383 if (!argp2) {
35384 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35385 }
35386 arg2 = reinterpret_cast< wxCursor * >(argp2);
35387 {
35388 PyThreadState* __tstate = wxPyBeginAllowThreads();
35389 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 {
35394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35395 }
35396 return resultobj;
35397 fail:
35398 return NULL;
35399 }
35400
35401
35402 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35403 PyObject *resultobj = 0;
35404 wxWindow *arg1 = (wxWindow *) 0 ;
35405 wxCursor result;
35406 void *argp1 = 0 ;
35407 int res1 = 0 ;
35408 PyObject *swig_obj[1] ;
35409
35410 if (!args) SWIG_fail;
35411 swig_obj[0] = args;
35412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35413 if (!SWIG_IsOK(res1)) {
35414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35415 }
35416 arg1 = reinterpret_cast< wxWindow * >(argp1);
35417 {
35418 PyThreadState* __tstate = wxPyBeginAllowThreads();
35419 result = (arg1)->GetCursor();
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35424 return resultobj;
35425 fail:
35426 return NULL;
35427 }
35428
35429
35430 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35431 PyObject *resultobj = 0;
35432 wxWindow *arg1 = (wxWindow *) 0 ;
35433 wxFont *arg2 = 0 ;
35434 bool result;
35435 void *argp1 = 0 ;
35436 int res1 = 0 ;
35437 void *argp2 = 0 ;
35438 int res2 = 0 ;
35439 PyObject * obj0 = 0 ;
35440 PyObject * obj1 = 0 ;
35441 char * kwnames[] = {
35442 (char *) "self",(char *) "font", NULL
35443 };
35444
35445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35449 }
35450 arg1 = reinterpret_cast< wxWindow * >(argp1);
35451 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35452 if (!SWIG_IsOK(res2)) {
35453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35454 }
35455 if (!argp2) {
35456 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35457 }
35458 arg2 = reinterpret_cast< wxFont * >(argp2);
35459 {
35460 PyThreadState* __tstate = wxPyBeginAllowThreads();
35461 result = (bool)(arg1)->SetFont((wxFont 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_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35475 PyObject *resultobj = 0;
35476 wxWindow *arg1 = (wxWindow *) 0 ;
35477 wxFont *arg2 = 0 ;
35478 void *argp1 = 0 ;
35479 int res1 = 0 ;
35480 void *argp2 = 0 ;
35481 int res2 = 0 ;
35482 PyObject * obj0 = 0 ;
35483 PyObject * obj1 = 0 ;
35484 char * kwnames[] = {
35485 (char *) "self",(char *) "font", NULL
35486 };
35487
35488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35490 if (!SWIG_IsOK(res1)) {
35491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35492 }
35493 arg1 = reinterpret_cast< wxWindow * >(argp1);
35494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35495 if (!SWIG_IsOK(res2)) {
35496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35497 }
35498 if (!argp2) {
35499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35500 }
35501 arg2 = reinterpret_cast< wxFont * >(argp2);
35502 {
35503 PyThreadState* __tstate = wxPyBeginAllowThreads();
35504 (arg1)->SetOwnFont((wxFont const &)*arg2);
35505 wxPyEndAllowThreads(__tstate);
35506 if (PyErr_Occurred()) SWIG_fail;
35507 }
35508 resultobj = SWIG_Py_Void();
35509 return resultobj;
35510 fail:
35511 return NULL;
35512 }
35513
35514
35515 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35516 PyObject *resultobj = 0;
35517 wxWindow *arg1 = (wxWindow *) 0 ;
35518 wxFont result;
35519 void *argp1 = 0 ;
35520 int res1 = 0 ;
35521 PyObject *swig_obj[1] ;
35522
35523 if (!args) SWIG_fail;
35524 swig_obj[0] = args;
35525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35526 if (!SWIG_IsOK(res1)) {
35527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35528 }
35529 arg1 = reinterpret_cast< wxWindow * >(argp1);
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 result = (arg1)->GetFont();
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35537 return resultobj;
35538 fail:
35539 return NULL;
35540 }
35541
35542
35543 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35544 PyObject *resultobj = 0;
35545 wxWindow *arg1 = (wxWindow *) 0 ;
35546 wxCaret *arg2 = (wxCaret *) 0 ;
35547 void *argp1 = 0 ;
35548 int res1 = 0 ;
35549 int res2 = 0 ;
35550 PyObject * obj0 = 0 ;
35551 PyObject * obj1 = 0 ;
35552 char * kwnames[] = {
35553 (char *) "self",(char *) "caret", NULL
35554 };
35555
35556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35558 if (!SWIG_IsOK(res1)) {
35559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35560 }
35561 arg1 = reinterpret_cast< wxWindow * >(argp1);
35562 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35563 if (!SWIG_IsOK(res2)) {
35564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35565 }
35566 {
35567 PyThreadState* __tstate = wxPyBeginAllowThreads();
35568 (arg1)->SetCaret(arg2);
35569 wxPyEndAllowThreads(__tstate);
35570 if (PyErr_Occurred()) SWIG_fail;
35571 }
35572 resultobj = SWIG_Py_Void();
35573 return resultobj;
35574 fail:
35575 return NULL;
35576 }
35577
35578
35579 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35580 PyObject *resultobj = 0;
35581 wxWindow *arg1 = (wxWindow *) 0 ;
35582 wxCaret *result = 0 ;
35583 void *argp1 = 0 ;
35584 int res1 = 0 ;
35585 PyObject *swig_obj[1] ;
35586
35587 if (!args) SWIG_fail;
35588 swig_obj[0] = args;
35589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35592 }
35593 arg1 = reinterpret_cast< wxWindow * >(argp1);
35594 {
35595 PyThreadState* __tstate = wxPyBeginAllowThreads();
35596 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35597 wxPyEndAllowThreads(__tstate);
35598 if (PyErr_Occurred()) SWIG_fail;
35599 }
35600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35601 return resultobj;
35602 fail:
35603 return NULL;
35604 }
35605
35606
35607 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35608 PyObject *resultobj = 0;
35609 wxWindow *arg1 = (wxWindow *) 0 ;
35610 int result;
35611 void *argp1 = 0 ;
35612 int res1 = 0 ;
35613 PyObject *swig_obj[1] ;
35614
35615 if (!args) SWIG_fail;
35616 swig_obj[0] = args;
35617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35618 if (!SWIG_IsOK(res1)) {
35619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35620 }
35621 arg1 = reinterpret_cast< wxWindow * >(argp1);
35622 {
35623 PyThreadState* __tstate = wxPyBeginAllowThreads();
35624 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35625 wxPyEndAllowThreads(__tstate);
35626 if (PyErr_Occurred()) SWIG_fail;
35627 }
35628 resultobj = SWIG_From_int(static_cast< int >(result));
35629 return resultobj;
35630 fail:
35631 return NULL;
35632 }
35633
35634
35635 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35636 PyObject *resultobj = 0;
35637 wxWindow *arg1 = (wxWindow *) 0 ;
35638 int result;
35639 void *argp1 = 0 ;
35640 int res1 = 0 ;
35641 PyObject *swig_obj[1] ;
35642
35643 if (!args) SWIG_fail;
35644 swig_obj[0] = args;
35645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35646 if (!SWIG_IsOK(res1)) {
35647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35648 }
35649 arg1 = reinterpret_cast< wxWindow * >(argp1);
35650 {
35651 PyThreadState* __tstate = wxPyBeginAllowThreads();
35652 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35653 wxPyEndAllowThreads(__tstate);
35654 if (PyErr_Occurred()) SWIG_fail;
35655 }
35656 resultobj = SWIG_From_int(static_cast< int >(result));
35657 return resultobj;
35658 fail:
35659 return NULL;
35660 }
35661
35662
35663 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35664 PyObject *resultobj = 0;
35665 wxWindow *arg1 = (wxWindow *) 0 ;
35666 wxString *arg2 = 0 ;
35667 int *arg3 = (int *) 0 ;
35668 int *arg4 = (int *) 0 ;
35669 void *argp1 = 0 ;
35670 int res1 = 0 ;
35671 bool temp2 = false ;
35672 int temp3 ;
35673 int res3 = SWIG_TMPOBJ ;
35674 int temp4 ;
35675 int res4 = SWIG_TMPOBJ ;
35676 PyObject * obj0 = 0 ;
35677 PyObject * obj1 = 0 ;
35678 char * kwnames[] = {
35679 (char *) "self",(char *) "string", NULL
35680 };
35681
35682 arg3 = &temp3;
35683 arg4 = &temp4;
35684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35686 if (!SWIG_IsOK(res1)) {
35687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35688 }
35689 arg1 = reinterpret_cast< wxWindow * >(argp1);
35690 {
35691 arg2 = wxString_in_helper(obj1);
35692 if (arg2 == NULL) SWIG_fail;
35693 temp2 = true;
35694 }
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 resultobj = SWIG_Py_Void();
35702 if (SWIG_IsTmpObj(res3)) {
35703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35704 } else {
35705 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35707 }
35708 if (SWIG_IsTmpObj(res4)) {
35709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35710 } else {
35711 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35713 }
35714 {
35715 if (temp2)
35716 delete arg2;
35717 }
35718 return resultobj;
35719 fail:
35720 {
35721 if (temp2)
35722 delete arg2;
35723 }
35724 return NULL;
35725 }
35726
35727
35728 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35729 PyObject *resultobj = 0;
35730 wxWindow *arg1 = (wxWindow *) 0 ;
35731 wxString *arg2 = 0 ;
35732 int *arg3 = (int *) 0 ;
35733 int *arg4 = (int *) 0 ;
35734 int *arg5 = (int *) 0 ;
35735 int *arg6 = (int *) 0 ;
35736 wxFont *arg7 = (wxFont *) NULL ;
35737 void *argp1 = 0 ;
35738 int res1 = 0 ;
35739 bool temp2 = false ;
35740 int temp3 ;
35741 int res3 = SWIG_TMPOBJ ;
35742 int temp4 ;
35743 int res4 = SWIG_TMPOBJ ;
35744 int temp5 ;
35745 int res5 = SWIG_TMPOBJ ;
35746 int temp6 ;
35747 int res6 = SWIG_TMPOBJ ;
35748 void *argp7 = 0 ;
35749 int res7 = 0 ;
35750 PyObject * obj0 = 0 ;
35751 PyObject * obj1 = 0 ;
35752 PyObject * obj2 = 0 ;
35753 char * kwnames[] = {
35754 (char *) "self",(char *) "string",(char *) "font", NULL
35755 };
35756
35757 arg3 = &temp3;
35758 arg4 = &temp4;
35759 arg5 = &temp5;
35760 arg6 = &temp6;
35761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35763 if (!SWIG_IsOK(res1)) {
35764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35765 }
35766 arg1 = reinterpret_cast< wxWindow * >(argp1);
35767 {
35768 arg2 = wxString_in_helper(obj1);
35769 if (arg2 == NULL) SWIG_fail;
35770 temp2 = true;
35771 }
35772 if (obj2) {
35773 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35774 if (!SWIG_IsOK(res7)) {
35775 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35776 }
35777 arg7 = reinterpret_cast< wxFont * >(argp7);
35778 }
35779 {
35780 PyThreadState* __tstate = wxPyBeginAllowThreads();
35781 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35782 wxPyEndAllowThreads(__tstate);
35783 if (PyErr_Occurred()) SWIG_fail;
35784 }
35785 resultobj = SWIG_Py_Void();
35786 if (SWIG_IsTmpObj(res3)) {
35787 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35788 } else {
35789 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35791 }
35792 if (SWIG_IsTmpObj(res4)) {
35793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35794 } else {
35795 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35797 }
35798 if (SWIG_IsTmpObj(res5)) {
35799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35800 } else {
35801 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35803 }
35804 if (SWIG_IsTmpObj(res6)) {
35805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35806 } else {
35807 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35809 }
35810 {
35811 if (temp2)
35812 delete arg2;
35813 }
35814 return resultobj;
35815 fail:
35816 {
35817 if (temp2)
35818 delete arg2;
35819 }
35820 return NULL;
35821 }
35822
35823
35824 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35825 PyObject *resultobj = 0;
35826 wxWindow *arg1 = (wxWindow *) 0 ;
35827 int *arg2 = (int *) 0 ;
35828 int *arg3 = (int *) 0 ;
35829 void *argp1 = 0 ;
35830 int res1 = 0 ;
35831 int temp2 ;
35832 int res2 = 0 ;
35833 int temp3 ;
35834 int res3 = 0 ;
35835 PyObject * obj0 = 0 ;
35836 PyObject * obj1 = 0 ;
35837 PyObject * obj2 = 0 ;
35838 char * kwnames[] = {
35839 (char *) "self",(char *) "x",(char *) "y", NULL
35840 };
35841
35842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35844 if (!SWIG_IsOK(res1)) {
35845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35846 }
35847 arg1 = reinterpret_cast< wxWindow * >(argp1);
35848 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35849 int val;
35850 int ecode = SWIG_AsVal_int(obj1, &val);
35851 if (!SWIG_IsOK(ecode)) {
35852 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35853 }
35854 temp2 = static_cast< int >(val);
35855 arg2 = &temp2;
35856 res2 = SWIG_AddTmpMask(ecode);
35857 }
35858 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35859 int val;
35860 int ecode = SWIG_AsVal_int(obj2, &val);
35861 if (!SWIG_IsOK(ecode)) {
35862 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35863 }
35864 temp3 = static_cast< int >(val);
35865 arg3 = &temp3;
35866 res3 = SWIG_AddTmpMask(ecode);
35867 }
35868 {
35869 PyThreadState* __tstate = wxPyBeginAllowThreads();
35870 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35871 wxPyEndAllowThreads(__tstate);
35872 if (PyErr_Occurred()) SWIG_fail;
35873 }
35874 resultobj = SWIG_Py_Void();
35875 if (SWIG_IsTmpObj(res2)) {
35876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35877 } else {
35878 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35880 }
35881 if (SWIG_IsTmpObj(res3)) {
35882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35883 } else {
35884 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35886 }
35887 return resultobj;
35888 fail:
35889 return NULL;
35890 }
35891
35892
35893 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35894 PyObject *resultobj = 0;
35895 wxWindow *arg1 = (wxWindow *) 0 ;
35896 int *arg2 = (int *) 0 ;
35897 int *arg3 = (int *) 0 ;
35898 void *argp1 = 0 ;
35899 int res1 = 0 ;
35900 int temp2 ;
35901 int res2 = 0 ;
35902 int temp3 ;
35903 int res3 = 0 ;
35904 PyObject * obj0 = 0 ;
35905 PyObject * obj1 = 0 ;
35906 PyObject * obj2 = 0 ;
35907 char * kwnames[] = {
35908 (char *) "self",(char *) "x",(char *) "y", NULL
35909 };
35910
35911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35913 if (!SWIG_IsOK(res1)) {
35914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35915 }
35916 arg1 = reinterpret_cast< wxWindow * >(argp1);
35917 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35918 int val;
35919 int ecode = SWIG_AsVal_int(obj1, &val);
35920 if (!SWIG_IsOK(ecode)) {
35921 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35922 }
35923 temp2 = static_cast< int >(val);
35924 arg2 = &temp2;
35925 res2 = SWIG_AddTmpMask(ecode);
35926 }
35927 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35928 int val;
35929 int ecode = SWIG_AsVal_int(obj2, &val);
35930 if (!SWIG_IsOK(ecode)) {
35931 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35932 }
35933 temp3 = static_cast< int >(val);
35934 arg3 = &temp3;
35935 res3 = SWIG_AddTmpMask(ecode);
35936 }
35937 {
35938 PyThreadState* __tstate = wxPyBeginAllowThreads();
35939 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35940 wxPyEndAllowThreads(__tstate);
35941 if (PyErr_Occurred()) SWIG_fail;
35942 }
35943 resultobj = SWIG_Py_Void();
35944 if (SWIG_IsTmpObj(res2)) {
35945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35946 } else {
35947 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35949 }
35950 if (SWIG_IsTmpObj(res3)) {
35951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35952 } else {
35953 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35955 }
35956 return resultobj;
35957 fail:
35958 return NULL;
35959 }
35960
35961
35962 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35963 PyObject *resultobj = 0;
35964 wxWindow *arg1 = (wxWindow *) 0 ;
35965 wxPoint *arg2 = 0 ;
35966 wxPoint result;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 wxPoint temp2 ;
35970 PyObject * obj0 = 0 ;
35971 PyObject * obj1 = 0 ;
35972 char * kwnames[] = {
35973 (char *) "self",(char *) "pt", NULL
35974 };
35975
35976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35978 if (!SWIG_IsOK(res1)) {
35979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35980 }
35981 arg1 = reinterpret_cast< wxWindow * >(argp1);
35982 {
35983 arg2 = &temp2;
35984 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35985 }
35986 {
35987 PyThreadState* __tstate = wxPyBeginAllowThreads();
35988 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35989 wxPyEndAllowThreads(__tstate);
35990 if (PyErr_Occurred()) SWIG_fail;
35991 }
35992 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35993 return resultobj;
35994 fail:
35995 return NULL;
35996 }
35997
35998
35999 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36000 PyObject *resultobj = 0;
36001 wxWindow *arg1 = (wxWindow *) 0 ;
36002 wxPoint *arg2 = 0 ;
36003 wxPoint result;
36004 void *argp1 = 0 ;
36005 int res1 = 0 ;
36006 wxPoint temp2 ;
36007 PyObject * obj0 = 0 ;
36008 PyObject * obj1 = 0 ;
36009 char * kwnames[] = {
36010 (char *) "self",(char *) "pt", NULL
36011 };
36012
36013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36015 if (!SWIG_IsOK(res1)) {
36016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36017 }
36018 arg1 = reinterpret_cast< wxWindow * >(argp1);
36019 {
36020 arg2 = &temp2;
36021 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36022 }
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36037 PyObject *resultobj = 0;
36038 wxWindow *arg1 = (wxWindow *) 0 ;
36039 int arg2 ;
36040 int arg3 ;
36041 wxHitTest result;
36042 void *argp1 = 0 ;
36043 int res1 = 0 ;
36044 int val2 ;
36045 int ecode2 = 0 ;
36046 int val3 ;
36047 int ecode3 = 0 ;
36048 PyObject * obj0 = 0 ;
36049 PyObject * obj1 = 0 ;
36050 PyObject * obj2 = 0 ;
36051 char * kwnames[] = {
36052 (char *) "self",(char *) "x",(char *) "y", NULL
36053 };
36054
36055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36057 if (!SWIG_IsOK(res1)) {
36058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36059 }
36060 arg1 = reinterpret_cast< wxWindow * >(argp1);
36061 ecode2 = SWIG_AsVal_int(obj1, &val2);
36062 if (!SWIG_IsOK(ecode2)) {
36063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36064 }
36065 arg2 = static_cast< int >(val2);
36066 ecode3 = SWIG_AsVal_int(obj2, &val3);
36067 if (!SWIG_IsOK(ecode3)) {
36068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36069 }
36070 arg3 = static_cast< int >(val3);
36071 {
36072 PyThreadState* __tstate = wxPyBeginAllowThreads();
36073 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36074 wxPyEndAllowThreads(__tstate);
36075 if (PyErr_Occurred()) SWIG_fail;
36076 }
36077 resultobj = SWIG_From_int(static_cast< int >(result));
36078 return resultobj;
36079 fail:
36080 return NULL;
36081 }
36082
36083
36084 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36085 PyObject *resultobj = 0;
36086 wxWindow *arg1 = (wxWindow *) 0 ;
36087 wxPoint *arg2 = 0 ;
36088 wxHitTest result;
36089 void *argp1 = 0 ;
36090 int res1 = 0 ;
36091 wxPoint temp2 ;
36092 PyObject * obj0 = 0 ;
36093 PyObject * obj1 = 0 ;
36094 char * kwnames[] = {
36095 (char *) "self",(char *) "pt", NULL
36096 };
36097
36098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36100 if (!SWIG_IsOK(res1)) {
36101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36102 }
36103 arg1 = reinterpret_cast< wxWindow * >(argp1);
36104 {
36105 arg2 = &temp2;
36106 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36107 }
36108 {
36109 PyThreadState* __tstate = wxPyBeginAllowThreads();
36110 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36111 wxPyEndAllowThreads(__tstate);
36112 if (PyErr_Occurred()) SWIG_fail;
36113 }
36114 resultobj = SWIG_From_int(static_cast< int >(result));
36115 return resultobj;
36116 fail:
36117 return NULL;
36118 }
36119
36120
36121 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36122 PyObject *resultobj = 0;
36123 wxWindow *arg1 = (wxWindow *) 0 ;
36124 long arg2 ;
36125 wxBorder result;
36126 void *argp1 = 0 ;
36127 int res1 = 0 ;
36128 long val2 ;
36129 int ecode2 = 0 ;
36130
36131 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36133 if (!SWIG_IsOK(res1)) {
36134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36135 }
36136 arg1 = reinterpret_cast< wxWindow * >(argp1);
36137 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36138 if (!SWIG_IsOK(ecode2)) {
36139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36140 }
36141 arg2 = static_cast< long >(val2);
36142 {
36143 PyThreadState* __tstate = wxPyBeginAllowThreads();
36144 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36145 wxPyEndAllowThreads(__tstate);
36146 if (PyErr_Occurred()) SWIG_fail;
36147 }
36148 resultobj = SWIG_From_int(static_cast< int >(result));
36149 return resultobj;
36150 fail:
36151 return NULL;
36152 }
36153
36154
36155 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36156 PyObject *resultobj = 0;
36157 wxWindow *arg1 = (wxWindow *) 0 ;
36158 wxBorder result;
36159 void *argp1 = 0 ;
36160 int res1 = 0 ;
36161
36162 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36164 if (!SWIG_IsOK(res1)) {
36165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36166 }
36167 arg1 = reinterpret_cast< wxWindow * >(argp1);
36168 {
36169 PyThreadState* __tstate = wxPyBeginAllowThreads();
36170 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36171 wxPyEndAllowThreads(__tstate);
36172 if (PyErr_Occurred()) SWIG_fail;
36173 }
36174 resultobj = SWIG_From_int(static_cast< int >(result));
36175 return resultobj;
36176 fail:
36177 return NULL;
36178 }
36179
36180
36181 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36182 int argc;
36183 PyObject *argv[3];
36184
36185 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36186 --argc;
36187 if (argc == 1) {
36188 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36189 }
36190 if (argc == 2) {
36191 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36192 }
36193
36194 fail:
36195 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36196 return NULL;
36197 }
36198
36199
36200 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36201 PyObject *resultobj = 0;
36202 wxWindow *arg1 = (wxWindow *) 0 ;
36203 long arg2 = (long) wxUPDATE_UI_NONE ;
36204 void *argp1 = 0 ;
36205 int res1 = 0 ;
36206 long val2 ;
36207 int ecode2 = 0 ;
36208 PyObject * obj0 = 0 ;
36209 PyObject * obj1 = 0 ;
36210 char * kwnames[] = {
36211 (char *) "self",(char *) "flags", NULL
36212 };
36213
36214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36216 if (!SWIG_IsOK(res1)) {
36217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36218 }
36219 arg1 = reinterpret_cast< wxWindow * >(argp1);
36220 if (obj1) {
36221 ecode2 = SWIG_AsVal_long(obj1, &val2);
36222 if (!SWIG_IsOK(ecode2)) {
36223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36224 }
36225 arg2 = static_cast< long >(val2);
36226 }
36227 {
36228 PyThreadState* __tstate = wxPyBeginAllowThreads();
36229 (arg1)->UpdateWindowUI(arg2);
36230 wxPyEndAllowThreads(__tstate);
36231 if (PyErr_Occurred()) SWIG_fail;
36232 }
36233 resultobj = SWIG_Py_Void();
36234 return resultobj;
36235 fail:
36236 return NULL;
36237 }
36238
36239
36240 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36241 PyObject *resultobj = 0;
36242 wxWindow *arg1 = (wxWindow *) 0 ;
36243 wxMenu *arg2 = (wxMenu *) 0 ;
36244 int arg3 = (int) -1 ;
36245 int arg4 = (int) -1 ;
36246 bool result;
36247 void *argp1 = 0 ;
36248 int res1 = 0 ;
36249 void *argp2 = 0 ;
36250 int res2 = 0 ;
36251 int val3 ;
36252 int ecode3 = 0 ;
36253 int val4 ;
36254 int ecode4 = 0 ;
36255 PyObject * obj0 = 0 ;
36256 PyObject * obj1 = 0 ;
36257 PyObject * obj2 = 0 ;
36258 PyObject * obj3 = 0 ;
36259 char * kwnames[] = {
36260 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36261 };
36262
36263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36265 if (!SWIG_IsOK(res1)) {
36266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36267 }
36268 arg1 = reinterpret_cast< wxWindow * >(argp1);
36269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36270 if (!SWIG_IsOK(res2)) {
36271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36272 }
36273 arg2 = reinterpret_cast< wxMenu * >(argp2);
36274 if (obj2) {
36275 ecode3 = SWIG_AsVal_int(obj2, &val3);
36276 if (!SWIG_IsOK(ecode3)) {
36277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36278 }
36279 arg3 = static_cast< int >(val3);
36280 }
36281 if (obj3) {
36282 ecode4 = SWIG_AsVal_int(obj3, &val4);
36283 if (!SWIG_IsOK(ecode4)) {
36284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36285 }
36286 arg4 = static_cast< int >(val4);
36287 }
36288 {
36289 PyThreadState* __tstate = wxPyBeginAllowThreads();
36290 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36291 wxPyEndAllowThreads(__tstate);
36292 if (PyErr_Occurred()) SWIG_fail;
36293 }
36294 {
36295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36296 }
36297 return resultobj;
36298 fail:
36299 return NULL;
36300 }
36301
36302
36303 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36304 PyObject *resultobj = 0;
36305 wxWindow *arg1 = (wxWindow *) 0 ;
36306 wxMenu *arg2 = (wxMenu *) 0 ;
36307 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36308 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36309 bool result;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 void *argp2 = 0 ;
36313 int res2 = 0 ;
36314 wxPoint temp3 ;
36315 PyObject * obj0 = 0 ;
36316 PyObject * obj1 = 0 ;
36317 PyObject * obj2 = 0 ;
36318 char * kwnames[] = {
36319 (char *) "self",(char *) "menu",(char *) "pos", NULL
36320 };
36321
36322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36324 if (!SWIG_IsOK(res1)) {
36325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36326 }
36327 arg1 = reinterpret_cast< wxWindow * >(argp1);
36328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36329 if (!SWIG_IsOK(res2)) {
36330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36331 }
36332 arg2 = reinterpret_cast< wxMenu * >(argp2);
36333 if (obj2) {
36334 {
36335 arg3 = &temp3;
36336 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36337 }
36338 }
36339 {
36340 PyThreadState* __tstate = wxPyBeginAllowThreads();
36341 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36342 wxPyEndAllowThreads(__tstate);
36343 if (PyErr_Occurred()) SWIG_fail;
36344 }
36345 {
36346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36347 }
36348 return resultobj;
36349 fail:
36350 return NULL;
36351 }
36352
36353
36354 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36355 PyObject *resultobj = 0;
36356 wxWindow *arg1 = (wxWindow *) 0 ;
36357 bool result;
36358 void *argp1 = 0 ;
36359 int res1 = 0 ;
36360 PyObject *swig_obj[1] ;
36361
36362 if (!args) SWIG_fail;
36363 swig_obj[0] = args;
36364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36365 if (!SWIG_IsOK(res1)) {
36366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36367 }
36368 arg1 = reinterpret_cast< wxWindow * >(argp1);
36369 {
36370 PyThreadState* __tstate = wxPyBeginAllowThreads();
36371 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36372 wxPyEndAllowThreads(__tstate);
36373 if (PyErr_Occurred()) SWIG_fail;
36374 }
36375 {
36376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36377 }
36378 return resultobj;
36379 fail:
36380 return NULL;
36381 }
36382
36383
36384 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36385 PyObject *resultobj = 0;
36386 wxWindow *arg1 = (wxWindow *) 0 ;
36387 long result;
36388 void *argp1 = 0 ;
36389 int res1 = 0 ;
36390 PyObject *swig_obj[1] ;
36391
36392 if (!args) SWIG_fail;
36393 swig_obj[0] = args;
36394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36395 if (!SWIG_IsOK(res1)) {
36396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36397 }
36398 arg1 = reinterpret_cast< wxWindow * >(argp1);
36399 {
36400 PyThreadState* __tstate = wxPyBeginAllowThreads();
36401 result = (long)wxWindow_GetHandle(arg1);
36402 wxPyEndAllowThreads(__tstate);
36403 if (PyErr_Occurred()) SWIG_fail;
36404 }
36405 resultobj = SWIG_From_long(static_cast< long >(result));
36406 return resultobj;
36407 fail:
36408 return NULL;
36409 }
36410
36411
36412 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36413 PyObject *resultobj = 0;
36414 wxWindow *arg1 = (wxWindow *) 0 ;
36415 long arg2 ;
36416 void *argp1 = 0 ;
36417 int res1 = 0 ;
36418 long val2 ;
36419 int ecode2 = 0 ;
36420 PyObject * obj0 = 0 ;
36421 PyObject * obj1 = 0 ;
36422 char * kwnames[] = {
36423 (char *) "self",(char *) "handle", NULL
36424 };
36425
36426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36428 if (!SWIG_IsOK(res1)) {
36429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36430 }
36431 arg1 = reinterpret_cast< wxWindow * >(argp1);
36432 ecode2 = SWIG_AsVal_long(obj1, &val2);
36433 if (!SWIG_IsOK(ecode2)) {
36434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36435 }
36436 arg2 = static_cast< long >(val2);
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 wxWindow_AssociateHandle(arg1,arg2);
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 resultobj = SWIG_Py_Void();
36444 return resultobj;
36445 fail:
36446 return NULL;
36447 }
36448
36449
36450 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36451 PyObject *resultobj = 0;
36452 wxWindow *arg1 = (wxWindow *) 0 ;
36453 void *argp1 = 0 ;
36454 int res1 = 0 ;
36455 PyObject *swig_obj[1] ;
36456
36457 if (!args) SWIG_fail;
36458 swig_obj[0] = args;
36459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36460 if (!SWIG_IsOK(res1)) {
36461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36462 }
36463 arg1 = reinterpret_cast< wxWindow * >(argp1);
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 (arg1)->DissociateHandle();
36467 wxPyEndAllowThreads(__tstate);
36468 if (PyErr_Occurred()) SWIG_fail;
36469 }
36470 resultobj = SWIG_Py_Void();
36471 return resultobj;
36472 fail:
36473 return NULL;
36474 }
36475
36476
36477 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36478 PyObject *resultobj = 0;
36479 wxWindow *arg1 = (wxWindow *) 0 ;
36480 wxPaintEvent *arg2 = 0 ;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 void *argp2 = 0 ;
36484 int res2 = 0 ;
36485 PyObject * obj0 = 0 ;
36486 PyObject * obj1 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "self",(char *) "event", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36495 }
36496 arg1 = reinterpret_cast< wxWindow * >(argp1);
36497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36498 if (!SWIG_IsOK(res2)) {
36499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36500 }
36501 if (!argp2) {
36502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36503 }
36504 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 (arg1)->OnPaint(*arg2);
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 resultobj = SWIG_Py_Void();
36512 return resultobj;
36513 fail:
36514 return NULL;
36515 }
36516
36517
36518 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36519 PyObject *resultobj = 0;
36520 wxWindow *arg1 = (wxWindow *) 0 ;
36521 int arg2 ;
36522 bool result;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 int val2 ;
36526 int ecode2 = 0 ;
36527 PyObject * obj0 = 0 ;
36528 PyObject * obj1 = 0 ;
36529 char * kwnames[] = {
36530 (char *) "self",(char *) "orient", NULL
36531 };
36532
36533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 ecode2 = SWIG_AsVal_int(obj1, &val2);
36540 if (!SWIG_IsOK(ecode2)) {
36541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36542 }
36543 arg2 = static_cast< int >(val2);
36544 {
36545 PyThreadState* __tstate = wxPyBeginAllowThreads();
36546 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36547 wxPyEndAllowThreads(__tstate);
36548 if (PyErr_Occurred()) SWIG_fail;
36549 }
36550 {
36551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36552 }
36553 return resultobj;
36554 fail:
36555 return NULL;
36556 }
36557
36558
36559 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36560 PyObject *resultobj = 0;
36561 wxWindow *arg1 = (wxWindow *) 0 ;
36562 int arg2 ;
36563 int arg3 ;
36564 int arg4 ;
36565 int arg5 ;
36566 bool arg6 = (bool) true ;
36567 void *argp1 = 0 ;
36568 int res1 = 0 ;
36569 int val2 ;
36570 int ecode2 = 0 ;
36571 int val3 ;
36572 int ecode3 = 0 ;
36573 int val4 ;
36574 int ecode4 = 0 ;
36575 int val5 ;
36576 int ecode5 = 0 ;
36577 bool val6 ;
36578 int ecode6 = 0 ;
36579 PyObject * obj0 = 0 ;
36580 PyObject * obj1 = 0 ;
36581 PyObject * obj2 = 0 ;
36582 PyObject * obj3 = 0 ;
36583 PyObject * obj4 = 0 ;
36584 PyObject * obj5 = 0 ;
36585 char * kwnames[] = {
36586 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36587 };
36588
36589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36591 if (!SWIG_IsOK(res1)) {
36592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 ecode2 = SWIG_AsVal_int(obj1, &val2);
36596 if (!SWIG_IsOK(ecode2)) {
36597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36598 }
36599 arg2 = static_cast< int >(val2);
36600 ecode3 = SWIG_AsVal_int(obj2, &val3);
36601 if (!SWIG_IsOK(ecode3)) {
36602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36603 }
36604 arg3 = static_cast< int >(val3);
36605 ecode4 = SWIG_AsVal_int(obj3, &val4);
36606 if (!SWIG_IsOK(ecode4)) {
36607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36608 }
36609 arg4 = static_cast< int >(val4);
36610 ecode5 = SWIG_AsVal_int(obj4, &val5);
36611 if (!SWIG_IsOK(ecode5)) {
36612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36613 }
36614 arg5 = static_cast< int >(val5);
36615 if (obj5) {
36616 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36617 if (!SWIG_IsOK(ecode6)) {
36618 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36619 }
36620 arg6 = static_cast< bool >(val6);
36621 }
36622 {
36623 PyThreadState* __tstate = wxPyBeginAllowThreads();
36624 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 resultobj = SWIG_Py_Void();
36629 return resultobj;
36630 fail:
36631 return NULL;
36632 }
36633
36634
36635 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36636 PyObject *resultobj = 0;
36637 wxWindow *arg1 = (wxWindow *) 0 ;
36638 int arg2 ;
36639 int arg3 ;
36640 bool arg4 = (bool) true ;
36641 void *argp1 = 0 ;
36642 int res1 = 0 ;
36643 int val2 ;
36644 int ecode2 = 0 ;
36645 int val3 ;
36646 int ecode3 = 0 ;
36647 bool val4 ;
36648 int ecode4 = 0 ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 PyObject * obj2 = 0 ;
36652 PyObject * obj3 = 0 ;
36653 char * kwnames[] = {
36654 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36655 };
36656
36657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36659 if (!SWIG_IsOK(res1)) {
36660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36661 }
36662 arg1 = reinterpret_cast< wxWindow * >(argp1);
36663 ecode2 = SWIG_AsVal_int(obj1, &val2);
36664 if (!SWIG_IsOK(ecode2)) {
36665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36666 }
36667 arg2 = static_cast< int >(val2);
36668 ecode3 = SWIG_AsVal_int(obj2, &val3);
36669 if (!SWIG_IsOK(ecode3)) {
36670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36671 }
36672 arg3 = static_cast< int >(val3);
36673 if (obj3) {
36674 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36675 if (!SWIG_IsOK(ecode4)) {
36676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36677 }
36678 arg4 = static_cast< bool >(val4);
36679 }
36680 {
36681 PyThreadState* __tstate = wxPyBeginAllowThreads();
36682 (arg1)->SetScrollPos(arg2,arg3,arg4);
36683 wxPyEndAllowThreads(__tstate);
36684 if (PyErr_Occurred()) SWIG_fail;
36685 }
36686 resultobj = SWIG_Py_Void();
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36694 PyObject *resultobj = 0;
36695 wxWindow *arg1 = (wxWindow *) 0 ;
36696 int arg2 ;
36697 int result;
36698 void *argp1 = 0 ;
36699 int res1 = 0 ;
36700 int val2 ;
36701 int ecode2 = 0 ;
36702 PyObject * obj0 = 0 ;
36703 PyObject * obj1 = 0 ;
36704 char * kwnames[] = {
36705 (char *) "self",(char *) "orientation", NULL
36706 };
36707
36708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36710 if (!SWIG_IsOK(res1)) {
36711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36712 }
36713 arg1 = reinterpret_cast< wxWindow * >(argp1);
36714 ecode2 = SWIG_AsVal_int(obj1, &val2);
36715 if (!SWIG_IsOK(ecode2)) {
36716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36717 }
36718 arg2 = static_cast< int >(val2);
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36722 wxPyEndAllowThreads(__tstate);
36723 if (PyErr_Occurred()) SWIG_fail;
36724 }
36725 resultobj = SWIG_From_int(static_cast< int >(result));
36726 return resultobj;
36727 fail:
36728 return NULL;
36729 }
36730
36731
36732 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36733 PyObject *resultobj = 0;
36734 wxWindow *arg1 = (wxWindow *) 0 ;
36735 int arg2 ;
36736 int result;
36737 void *argp1 = 0 ;
36738 int res1 = 0 ;
36739 int val2 ;
36740 int ecode2 = 0 ;
36741 PyObject * obj0 = 0 ;
36742 PyObject * obj1 = 0 ;
36743 char * kwnames[] = {
36744 (char *) "self",(char *) "orientation", NULL
36745 };
36746
36747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36749 if (!SWIG_IsOK(res1)) {
36750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36751 }
36752 arg1 = reinterpret_cast< wxWindow * >(argp1);
36753 ecode2 = SWIG_AsVal_int(obj1, &val2);
36754 if (!SWIG_IsOK(ecode2)) {
36755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36756 }
36757 arg2 = static_cast< int >(val2);
36758 {
36759 PyThreadState* __tstate = wxPyBeginAllowThreads();
36760 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36761 wxPyEndAllowThreads(__tstate);
36762 if (PyErr_Occurred()) SWIG_fail;
36763 }
36764 resultobj = SWIG_From_int(static_cast< int >(result));
36765 return resultobj;
36766 fail:
36767 return NULL;
36768 }
36769
36770
36771 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36772 PyObject *resultobj = 0;
36773 wxWindow *arg1 = (wxWindow *) 0 ;
36774 int arg2 ;
36775 int result;
36776 void *argp1 = 0 ;
36777 int res1 = 0 ;
36778 int val2 ;
36779 int ecode2 = 0 ;
36780 PyObject * obj0 = 0 ;
36781 PyObject * obj1 = 0 ;
36782 char * kwnames[] = {
36783 (char *) "self",(char *) "orientation", NULL
36784 };
36785
36786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36788 if (!SWIG_IsOK(res1)) {
36789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36790 }
36791 arg1 = reinterpret_cast< wxWindow * >(argp1);
36792 ecode2 = SWIG_AsVal_int(obj1, &val2);
36793 if (!SWIG_IsOK(ecode2)) {
36794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36795 }
36796 arg2 = static_cast< int >(val2);
36797 {
36798 PyThreadState* __tstate = wxPyBeginAllowThreads();
36799 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36800 wxPyEndAllowThreads(__tstate);
36801 if (PyErr_Occurred()) SWIG_fail;
36802 }
36803 resultobj = SWIG_From_int(static_cast< int >(result));
36804 return resultobj;
36805 fail:
36806 return NULL;
36807 }
36808
36809
36810 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36811 PyObject *resultobj = 0;
36812 wxWindow *arg1 = (wxWindow *) 0 ;
36813 int arg2 ;
36814 int arg3 ;
36815 wxRect *arg4 = (wxRect *) NULL ;
36816 void *argp1 = 0 ;
36817 int res1 = 0 ;
36818 int val2 ;
36819 int ecode2 = 0 ;
36820 int val3 ;
36821 int ecode3 = 0 ;
36822 void *argp4 = 0 ;
36823 int res4 = 0 ;
36824 PyObject * obj0 = 0 ;
36825 PyObject * obj1 = 0 ;
36826 PyObject * obj2 = 0 ;
36827 PyObject * obj3 = 0 ;
36828 char * kwnames[] = {
36829 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36830 };
36831
36832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36834 if (!SWIG_IsOK(res1)) {
36835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36836 }
36837 arg1 = reinterpret_cast< wxWindow * >(argp1);
36838 ecode2 = SWIG_AsVal_int(obj1, &val2);
36839 if (!SWIG_IsOK(ecode2)) {
36840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36841 }
36842 arg2 = static_cast< int >(val2);
36843 ecode3 = SWIG_AsVal_int(obj2, &val3);
36844 if (!SWIG_IsOK(ecode3)) {
36845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36846 }
36847 arg3 = static_cast< int >(val3);
36848 if (obj3) {
36849 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36850 if (!SWIG_IsOK(res4)) {
36851 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36852 }
36853 arg4 = reinterpret_cast< wxRect * >(argp4);
36854 }
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36858 wxPyEndAllowThreads(__tstate);
36859 if (PyErr_Occurred()) SWIG_fail;
36860 }
36861 resultobj = SWIG_Py_Void();
36862 return resultobj;
36863 fail:
36864 return NULL;
36865 }
36866
36867
36868 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36869 PyObject *resultobj = 0;
36870 wxWindow *arg1 = (wxWindow *) 0 ;
36871 int arg2 ;
36872 bool result;
36873 void *argp1 = 0 ;
36874 int res1 = 0 ;
36875 int val2 ;
36876 int ecode2 = 0 ;
36877 PyObject * obj0 = 0 ;
36878 PyObject * obj1 = 0 ;
36879 char * kwnames[] = {
36880 (char *) "self",(char *) "lines", NULL
36881 };
36882
36883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36885 if (!SWIG_IsOK(res1)) {
36886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36887 }
36888 arg1 = reinterpret_cast< wxWindow * >(argp1);
36889 ecode2 = SWIG_AsVal_int(obj1, &val2);
36890 if (!SWIG_IsOK(ecode2)) {
36891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36892 }
36893 arg2 = static_cast< int >(val2);
36894 {
36895 PyThreadState* __tstate = wxPyBeginAllowThreads();
36896 result = (bool)(arg1)->ScrollLines(arg2);
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 {
36901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36902 }
36903 return resultobj;
36904 fail:
36905 return NULL;
36906 }
36907
36908
36909 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36910 PyObject *resultobj = 0;
36911 wxWindow *arg1 = (wxWindow *) 0 ;
36912 int arg2 ;
36913 bool result;
36914 void *argp1 = 0 ;
36915 int res1 = 0 ;
36916 int val2 ;
36917 int ecode2 = 0 ;
36918 PyObject * obj0 = 0 ;
36919 PyObject * obj1 = 0 ;
36920 char * kwnames[] = {
36921 (char *) "self",(char *) "pages", NULL
36922 };
36923
36924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36928 }
36929 arg1 = reinterpret_cast< wxWindow * >(argp1);
36930 ecode2 = SWIG_AsVal_int(obj1, &val2);
36931 if (!SWIG_IsOK(ecode2)) {
36932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36933 }
36934 arg2 = static_cast< int >(val2);
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 result = (bool)(arg1)->ScrollPages(arg2);
36938 wxPyEndAllowThreads(__tstate);
36939 if (PyErr_Occurred()) SWIG_fail;
36940 }
36941 {
36942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36943 }
36944 return resultobj;
36945 fail:
36946 return NULL;
36947 }
36948
36949
36950 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36951 PyObject *resultobj = 0;
36952 wxWindow *arg1 = (wxWindow *) 0 ;
36953 bool result;
36954 void *argp1 = 0 ;
36955 int res1 = 0 ;
36956 PyObject *swig_obj[1] ;
36957
36958 if (!args) SWIG_fail;
36959 swig_obj[0] = args;
36960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36961 if (!SWIG_IsOK(res1)) {
36962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36963 }
36964 arg1 = reinterpret_cast< wxWindow * >(argp1);
36965 {
36966 PyThreadState* __tstate = wxPyBeginAllowThreads();
36967 result = (bool)(arg1)->LineUp();
36968 wxPyEndAllowThreads(__tstate);
36969 if (PyErr_Occurred()) SWIG_fail;
36970 }
36971 {
36972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36973 }
36974 return resultobj;
36975 fail:
36976 return NULL;
36977 }
36978
36979
36980 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36981 PyObject *resultobj = 0;
36982 wxWindow *arg1 = (wxWindow *) 0 ;
36983 bool result;
36984 void *argp1 = 0 ;
36985 int res1 = 0 ;
36986 PyObject *swig_obj[1] ;
36987
36988 if (!args) SWIG_fail;
36989 swig_obj[0] = args;
36990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36991 if (!SWIG_IsOK(res1)) {
36992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36993 }
36994 arg1 = reinterpret_cast< wxWindow * >(argp1);
36995 {
36996 PyThreadState* __tstate = wxPyBeginAllowThreads();
36997 result = (bool)(arg1)->LineDown();
36998 wxPyEndAllowThreads(__tstate);
36999 if (PyErr_Occurred()) SWIG_fail;
37000 }
37001 {
37002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37003 }
37004 return resultobj;
37005 fail:
37006 return NULL;
37007 }
37008
37009
37010 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37011 PyObject *resultobj = 0;
37012 wxWindow *arg1 = (wxWindow *) 0 ;
37013 bool result;
37014 void *argp1 = 0 ;
37015 int res1 = 0 ;
37016 PyObject *swig_obj[1] ;
37017
37018 if (!args) SWIG_fail;
37019 swig_obj[0] = args;
37020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37021 if (!SWIG_IsOK(res1)) {
37022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37023 }
37024 arg1 = reinterpret_cast< wxWindow * >(argp1);
37025 {
37026 PyThreadState* __tstate = wxPyBeginAllowThreads();
37027 result = (bool)(arg1)->PageUp();
37028 wxPyEndAllowThreads(__tstate);
37029 if (PyErr_Occurred()) SWIG_fail;
37030 }
37031 {
37032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37033 }
37034 return resultobj;
37035 fail:
37036 return NULL;
37037 }
37038
37039
37040 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37041 PyObject *resultobj = 0;
37042 wxWindow *arg1 = (wxWindow *) 0 ;
37043 bool result;
37044 void *argp1 = 0 ;
37045 int res1 = 0 ;
37046 PyObject *swig_obj[1] ;
37047
37048 if (!args) SWIG_fail;
37049 swig_obj[0] = args;
37050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37051 if (!SWIG_IsOK(res1)) {
37052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37053 }
37054 arg1 = reinterpret_cast< wxWindow * >(argp1);
37055 {
37056 PyThreadState* __tstate = wxPyBeginAllowThreads();
37057 result = (bool)(arg1)->PageDown();
37058 wxPyEndAllowThreads(__tstate);
37059 if (PyErr_Occurred()) SWIG_fail;
37060 }
37061 {
37062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37063 }
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 wxString *arg2 = 0 ;
37074 void *argp1 = 0 ;
37075 int res1 = 0 ;
37076 bool temp2 = false ;
37077 PyObject * obj0 = 0 ;
37078 PyObject * obj1 = 0 ;
37079 char * kwnames[] = {
37080 (char *) "self",(char *) "text", NULL
37081 };
37082
37083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37087 }
37088 arg1 = reinterpret_cast< wxWindow * >(argp1);
37089 {
37090 arg2 = wxString_in_helper(obj1);
37091 if (arg2 == NULL) SWIG_fail;
37092 temp2 = true;
37093 }
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 (arg1)->SetHelpText((wxString const &)*arg2);
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 resultobj = SWIG_Py_Void();
37101 {
37102 if (temp2)
37103 delete arg2;
37104 }
37105 return resultobj;
37106 fail:
37107 {
37108 if (temp2)
37109 delete arg2;
37110 }
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37116 PyObject *resultobj = 0;
37117 wxWindow *arg1 = (wxWindow *) 0 ;
37118 wxString *arg2 = 0 ;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 bool temp2 = false ;
37122 PyObject * obj0 = 0 ;
37123 PyObject * obj1 = 0 ;
37124 char * kwnames[] = {
37125 (char *) "self",(char *) "text", NULL
37126 };
37127
37128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37130 if (!SWIG_IsOK(res1)) {
37131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37132 }
37133 arg1 = reinterpret_cast< wxWindow * >(argp1);
37134 {
37135 arg2 = wxString_in_helper(obj1);
37136 if (arg2 == NULL) SWIG_fail;
37137 temp2 = true;
37138 }
37139 {
37140 PyThreadState* __tstate = wxPyBeginAllowThreads();
37141 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37142 wxPyEndAllowThreads(__tstate);
37143 if (PyErr_Occurred()) SWIG_fail;
37144 }
37145 resultobj = SWIG_Py_Void();
37146 {
37147 if (temp2)
37148 delete arg2;
37149 }
37150 return resultobj;
37151 fail:
37152 {
37153 if (temp2)
37154 delete arg2;
37155 }
37156 return NULL;
37157 }
37158
37159
37160 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37161 PyObject *resultobj = 0;
37162 wxWindow *arg1 = (wxWindow *) 0 ;
37163 wxPoint *arg2 = 0 ;
37164 wxHelpEvent::Origin arg3 ;
37165 wxString result;
37166 void *argp1 = 0 ;
37167 int res1 = 0 ;
37168 wxPoint temp2 ;
37169 void *argp3 ;
37170 int res3 = 0 ;
37171 PyObject * obj0 = 0 ;
37172 PyObject * obj1 = 0 ;
37173 PyObject * obj2 = 0 ;
37174 char * kwnames[] = {
37175 (char *) "self",(char *) "pt",(char *) "origin", NULL
37176 };
37177
37178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37180 if (!SWIG_IsOK(res1)) {
37181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37182 }
37183 arg1 = reinterpret_cast< wxWindow * >(argp1);
37184 {
37185 arg2 = &temp2;
37186 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37187 }
37188 {
37189 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37190 if (!SWIG_IsOK(res3)) {
37191 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37192 }
37193 if (!argp3) {
37194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37195 } else {
37196 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37197 arg3 = *temp;
37198 if (SWIG_IsNewObj(res3)) delete temp;
37199 }
37200 }
37201 {
37202 PyThreadState* __tstate = wxPyBeginAllowThreads();
37203 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37204 wxPyEndAllowThreads(__tstate);
37205 if (PyErr_Occurred()) SWIG_fail;
37206 }
37207 {
37208 #if wxUSE_UNICODE
37209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37210 #else
37211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37212 #endif
37213 }
37214 return resultobj;
37215 fail:
37216 return NULL;
37217 }
37218
37219
37220 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37221 PyObject *resultobj = 0;
37222 wxWindow *arg1 = (wxWindow *) 0 ;
37223 wxString result;
37224 void *argp1 = 0 ;
37225 int res1 = 0 ;
37226 PyObject *swig_obj[1] ;
37227
37228 if (!args) SWIG_fail;
37229 swig_obj[0] = args;
37230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37231 if (!SWIG_IsOK(res1)) {
37232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37233 }
37234 arg1 = reinterpret_cast< wxWindow * >(argp1);
37235 {
37236 PyThreadState* __tstate = wxPyBeginAllowThreads();
37237 result = ((wxWindow const *)arg1)->GetHelpText();
37238 wxPyEndAllowThreads(__tstate);
37239 if (PyErr_Occurred()) SWIG_fail;
37240 }
37241 {
37242 #if wxUSE_UNICODE
37243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37244 #else
37245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37246 #endif
37247 }
37248 return resultobj;
37249 fail:
37250 return NULL;
37251 }
37252
37253
37254 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37255 PyObject *resultobj = 0;
37256 wxWindow *arg1 = (wxWindow *) 0 ;
37257 wxString *arg2 = 0 ;
37258 void *argp1 = 0 ;
37259 int res1 = 0 ;
37260 bool temp2 = false ;
37261 PyObject * obj0 = 0 ;
37262 PyObject * obj1 = 0 ;
37263 char * kwnames[] = {
37264 (char *) "self",(char *) "tip", NULL
37265 };
37266
37267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37269 if (!SWIG_IsOK(res1)) {
37270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37271 }
37272 arg1 = reinterpret_cast< wxWindow * >(argp1);
37273 {
37274 arg2 = wxString_in_helper(obj1);
37275 if (arg2 == NULL) SWIG_fail;
37276 temp2 = true;
37277 }
37278 {
37279 PyThreadState* __tstate = wxPyBeginAllowThreads();
37280 (arg1)->SetToolTip((wxString const &)*arg2);
37281 wxPyEndAllowThreads(__tstate);
37282 if (PyErr_Occurred()) SWIG_fail;
37283 }
37284 resultobj = SWIG_Py_Void();
37285 {
37286 if (temp2)
37287 delete arg2;
37288 }
37289 return resultobj;
37290 fail:
37291 {
37292 if (temp2)
37293 delete arg2;
37294 }
37295 return NULL;
37296 }
37297
37298
37299 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37300 PyObject *resultobj = 0;
37301 wxWindow *arg1 = (wxWindow *) 0 ;
37302 wxToolTip *arg2 = (wxToolTip *) 0 ;
37303 void *argp1 = 0 ;
37304 int res1 = 0 ;
37305 int res2 = 0 ;
37306 PyObject * obj0 = 0 ;
37307 PyObject * obj1 = 0 ;
37308 char * kwnames[] = {
37309 (char *) "self",(char *) "tip", NULL
37310 };
37311
37312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37314 if (!SWIG_IsOK(res1)) {
37315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37316 }
37317 arg1 = reinterpret_cast< wxWindow * >(argp1);
37318 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37319 if (!SWIG_IsOK(res2)) {
37320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37321 }
37322 {
37323 PyThreadState* __tstate = wxPyBeginAllowThreads();
37324 (arg1)->SetToolTip(arg2);
37325 wxPyEndAllowThreads(__tstate);
37326 if (PyErr_Occurred()) SWIG_fail;
37327 }
37328 resultobj = SWIG_Py_Void();
37329 return resultobj;
37330 fail:
37331 return NULL;
37332 }
37333
37334
37335 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37336 PyObject *resultobj = 0;
37337 wxWindow *arg1 = (wxWindow *) 0 ;
37338 wxToolTip *result = 0 ;
37339 void *argp1 = 0 ;
37340 int res1 = 0 ;
37341 PyObject *swig_obj[1] ;
37342
37343 if (!args) SWIG_fail;
37344 swig_obj[0] = args;
37345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37346 if (!SWIG_IsOK(res1)) {
37347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37348 }
37349 arg1 = reinterpret_cast< wxWindow * >(argp1);
37350 {
37351 PyThreadState* __tstate = wxPyBeginAllowThreads();
37352 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37353 wxPyEndAllowThreads(__tstate);
37354 if (PyErr_Occurred()) SWIG_fail;
37355 }
37356 {
37357 resultobj = wxPyMake_wxObject(result, (bool)0);
37358 }
37359 return resultobj;
37360 fail:
37361 return NULL;
37362 }
37363
37364
37365 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37366 PyObject *resultobj = 0;
37367 wxWindow *arg1 = (wxWindow *) 0 ;
37368 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37369 void *argp1 = 0 ;
37370 int res1 = 0 ;
37371 int res2 = 0 ;
37372 PyObject * obj0 = 0 ;
37373 PyObject * obj1 = 0 ;
37374 char * kwnames[] = {
37375 (char *) "self",(char *) "dropTarget", NULL
37376 };
37377
37378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37380 if (!SWIG_IsOK(res1)) {
37381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37382 }
37383 arg1 = reinterpret_cast< wxWindow * >(argp1);
37384 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37385 if (!SWIG_IsOK(res2)) {
37386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37387 }
37388 {
37389 PyThreadState* __tstate = wxPyBeginAllowThreads();
37390 (arg1)->SetDropTarget(arg2);
37391 wxPyEndAllowThreads(__tstate);
37392 if (PyErr_Occurred()) SWIG_fail;
37393 }
37394 resultobj = SWIG_Py_Void();
37395 return resultobj;
37396 fail:
37397 return NULL;
37398 }
37399
37400
37401 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37402 PyObject *resultobj = 0;
37403 wxWindow *arg1 = (wxWindow *) 0 ;
37404 wxPyDropTarget *result = 0 ;
37405 void *argp1 = 0 ;
37406 int res1 = 0 ;
37407 PyObject *swig_obj[1] ;
37408
37409 if (!args) SWIG_fail;
37410 swig_obj[0] = args;
37411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37412 if (!SWIG_IsOK(res1)) {
37413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37414 }
37415 arg1 = reinterpret_cast< wxWindow * >(argp1);
37416 {
37417 PyThreadState* __tstate = wxPyBeginAllowThreads();
37418 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37419 wxPyEndAllowThreads(__tstate);
37420 if (PyErr_Occurred()) SWIG_fail;
37421 }
37422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37423 return resultobj;
37424 fail:
37425 return NULL;
37426 }
37427
37428
37429 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37430 PyObject *resultobj = 0;
37431 wxWindow *arg1 = (wxWindow *) 0 ;
37432 bool arg2 ;
37433 void *argp1 = 0 ;
37434 int res1 = 0 ;
37435 bool val2 ;
37436 int ecode2 = 0 ;
37437 PyObject * obj0 = 0 ;
37438 PyObject * obj1 = 0 ;
37439 char * kwnames[] = {
37440 (char *) "self",(char *) "accept", NULL
37441 };
37442
37443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37445 if (!SWIG_IsOK(res1)) {
37446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37447 }
37448 arg1 = reinterpret_cast< wxWindow * >(argp1);
37449 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37450 if (!SWIG_IsOK(ecode2)) {
37451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37452 }
37453 arg2 = static_cast< bool >(val2);
37454 {
37455 PyThreadState* __tstate = wxPyBeginAllowThreads();
37456 (arg1)->DragAcceptFiles(arg2);
37457 wxPyEndAllowThreads(__tstate);
37458 if (PyErr_Occurred()) SWIG_fail;
37459 }
37460 resultobj = SWIG_Py_Void();
37461 return resultobj;
37462 fail:
37463 return NULL;
37464 }
37465
37466
37467 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37468 PyObject *resultobj = 0;
37469 wxWindow *arg1 = (wxWindow *) 0 ;
37470 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37471 void *argp1 = 0 ;
37472 int res1 = 0 ;
37473 int res2 = 0 ;
37474 PyObject * obj0 = 0 ;
37475 PyObject * obj1 = 0 ;
37476 char * kwnames[] = {
37477 (char *) "self",(char *) "constraints", NULL
37478 };
37479
37480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37482 if (!SWIG_IsOK(res1)) {
37483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37484 }
37485 arg1 = reinterpret_cast< wxWindow * >(argp1);
37486 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37487 if (!SWIG_IsOK(res2)) {
37488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37489 }
37490 {
37491 PyThreadState* __tstate = wxPyBeginAllowThreads();
37492 (arg1)->SetConstraints(arg2);
37493 wxPyEndAllowThreads(__tstate);
37494 if (PyErr_Occurred()) SWIG_fail;
37495 }
37496 resultobj = SWIG_Py_Void();
37497 return resultobj;
37498 fail:
37499 return NULL;
37500 }
37501
37502
37503 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37504 PyObject *resultobj = 0;
37505 wxWindow *arg1 = (wxWindow *) 0 ;
37506 wxLayoutConstraints *result = 0 ;
37507 void *argp1 = 0 ;
37508 int res1 = 0 ;
37509 PyObject *swig_obj[1] ;
37510
37511 if (!args) SWIG_fail;
37512 swig_obj[0] = args;
37513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37514 if (!SWIG_IsOK(res1)) {
37515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37516 }
37517 arg1 = reinterpret_cast< wxWindow * >(argp1);
37518 {
37519 PyThreadState* __tstate = wxPyBeginAllowThreads();
37520 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37521 wxPyEndAllowThreads(__tstate);
37522 if (PyErr_Occurred()) SWIG_fail;
37523 }
37524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37525 return resultobj;
37526 fail:
37527 return NULL;
37528 }
37529
37530
37531 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37532 PyObject *resultobj = 0;
37533 wxWindow *arg1 = (wxWindow *) 0 ;
37534 bool arg2 ;
37535 void *argp1 = 0 ;
37536 int res1 = 0 ;
37537 bool val2 ;
37538 int ecode2 = 0 ;
37539 PyObject * obj0 = 0 ;
37540 PyObject * obj1 = 0 ;
37541 char * kwnames[] = {
37542 (char *) "self",(char *) "autoLayout", NULL
37543 };
37544
37545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37547 if (!SWIG_IsOK(res1)) {
37548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37549 }
37550 arg1 = reinterpret_cast< wxWindow * >(argp1);
37551 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37552 if (!SWIG_IsOK(ecode2)) {
37553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37554 }
37555 arg2 = static_cast< bool >(val2);
37556 {
37557 PyThreadState* __tstate = wxPyBeginAllowThreads();
37558 (arg1)->SetAutoLayout(arg2);
37559 wxPyEndAllowThreads(__tstate);
37560 if (PyErr_Occurred()) SWIG_fail;
37561 }
37562 resultobj = SWIG_Py_Void();
37563 return resultobj;
37564 fail:
37565 return NULL;
37566 }
37567
37568
37569 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37570 PyObject *resultobj = 0;
37571 wxWindow *arg1 = (wxWindow *) 0 ;
37572 bool result;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 PyObject *swig_obj[1] ;
37576
37577 if (!args) SWIG_fail;
37578 swig_obj[0] = args;
37579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37580 if (!SWIG_IsOK(res1)) {
37581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37582 }
37583 arg1 = reinterpret_cast< wxWindow * >(argp1);
37584 {
37585 PyThreadState* __tstate = wxPyBeginAllowThreads();
37586 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37587 wxPyEndAllowThreads(__tstate);
37588 if (PyErr_Occurred()) SWIG_fail;
37589 }
37590 {
37591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37592 }
37593 return resultobj;
37594 fail:
37595 return NULL;
37596 }
37597
37598
37599 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37600 PyObject *resultobj = 0;
37601 wxWindow *arg1 = (wxWindow *) 0 ;
37602 bool result;
37603 void *argp1 = 0 ;
37604 int res1 = 0 ;
37605 PyObject *swig_obj[1] ;
37606
37607 if (!args) SWIG_fail;
37608 swig_obj[0] = args;
37609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37610 if (!SWIG_IsOK(res1)) {
37611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37612 }
37613 arg1 = reinterpret_cast< wxWindow * >(argp1);
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 result = (bool)(arg1)->Layout();
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 {
37621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37622 }
37623 return resultobj;
37624 fail:
37625 return NULL;
37626 }
37627
37628
37629 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37630 PyObject *resultobj = 0;
37631 wxWindow *arg1 = (wxWindow *) 0 ;
37632 wxSizer *arg2 = (wxSizer *) 0 ;
37633 bool arg3 = (bool) true ;
37634 void *argp1 = 0 ;
37635 int res1 = 0 ;
37636 int res2 = 0 ;
37637 bool val3 ;
37638 int ecode3 = 0 ;
37639 PyObject * obj0 = 0 ;
37640 PyObject * obj1 = 0 ;
37641 PyObject * obj2 = 0 ;
37642 char * kwnames[] = {
37643 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37644 };
37645
37646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37648 if (!SWIG_IsOK(res1)) {
37649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37650 }
37651 arg1 = reinterpret_cast< wxWindow * >(argp1);
37652 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37653 if (!SWIG_IsOK(res2)) {
37654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37655 }
37656 if (obj2) {
37657 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37658 if (!SWIG_IsOK(ecode3)) {
37659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37660 }
37661 arg3 = static_cast< bool >(val3);
37662 }
37663 {
37664 PyThreadState* __tstate = wxPyBeginAllowThreads();
37665 (arg1)->SetSizer(arg2,arg3);
37666 wxPyEndAllowThreads(__tstate);
37667 if (PyErr_Occurred()) SWIG_fail;
37668 }
37669 resultobj = SWIG_Py_Void();
37670 return resultobj;
37671 fail:
37672 return NULL;
37673 }
37674
37675
37676 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37677 PyObject *resultobj = 0;
37678 wxWindow *arg1 = (wxWindow *) 0 ;
37679 wxSizer *arg2 = (wxSizer *) 0 ;
37680 bool arg3 = (bool) true ;
37681 void *argp1 = 0 ;
37682 int res1 = 0 ;
37683 int res2 = 0 ;
37684 bool val3 ;
37685 int ecode3 = 0 ;
37686 PyObject * obj0 = 0 ;
37687 PyObject * obj1 = 0 ;
37688 PyObject * obj2 = 0 ;
37689 char * kwnames[] = {
37690 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37691 };
37692
37693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37695 if (!SWIG_IsOK(res1)) {
37696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37697 }
37698 arg1 = reinterpret_cast< wxWindow * >(argp1);
37699 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37700 if (!SWIG_IsOK(res2)) {
37701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37702 }
37703 if (obj2) {
37704 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37705 if (!SWIG_IsOK(ecode3)) {
37706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37707 }
37708 arg3 = static_cast< bool >(val3);
37709 }
37710 {
37711 PyThreadState* __tstate = wxPyBeginAllowThreads();
37712 (arg1)->SetSizerAndFit(arg2,arg3);
37713 wxPyEndAllowThreads(__tstate);
37714 if (PyErr_Occurred()) SWIG_fail;
37715 }
37716 resultobj = SWIG_Py_Void();
37717 return resultobj;
37718 fail:
37719 return NULL;
37720 }
37721
37722
37723 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37724 PyObject *resultobj = 0;
37725 wxWindow *arg1 = (wxWindow *) 0 ;
37726 wxSizer *result = 0 ;
37727 void *argp1 = 0 ;
37728 int res1 = 0 ;
37729 PyObject *swig_obj[1] ;
37730
37731 if (!args) SWIG_fail;
37732 swig_obj[0] = args;
37733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37734 if (!SWIG_IsOK(res1)) {
37735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37736 }
37737 arg1 = reinterpret_cast< wxWindow * >(argp1);
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37741 wxPyEndAllowThreads(__tstate);
37742 if (PyErr_Occurred()) SWIG_fail;
37743 }
37744 {
37745 resultobj = wxPyMake_wxObject(result, (bool)0);
37746 }
37747 return resultobj;
37748 fail:
37749 return NULL;
37750 }
37751
37752
37753 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37754 PyObject *resultobj = 0;
37755 wxWindow *arg1 = (wxWindow *) 0 ;
37756 wxSizer *arg2 = (wxSizer *) 0 ;
37757 void *argp1 = 0 ;
37758 int res1 = 0 ;
37759 void *argp2 = 0 ;
37760 int res2 = 0 ;
37761 PyObject * obj0 = 0 ;
37762 PyObject * obj1 = 0 ;
37763 char * kwnames[] = {
37764 (char *) "self",(char *) "sizer", NULL
37765 };
37766
37767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37769 if (!SWIG_IsOK(res1)) {
37770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37771 }
37772 arg1 = reinterpret_cast< wxWindow * >(argp1);
37773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37774 if (!SWIG_IsOK(res2)) {
37775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37776 }
37777 arg2 = reinterpret_cast< wxSizer * >(argp2);
37778 {
37779 PyThreadState* __tstate = wxPyBeginAllowThreads();
37780 (arg1)->SetContainingSizer(arg2);
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 resultobj = SWIG_Py_Void();
37785 return resultobj;
37786 fail:
37787 return NULL;
37788 }
37789
37790
37791 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37792 PyObject *resultobj = 0;
37793 wxWindow *arg1 = (wxWindow *) 0 ;
37794 wxSizer *result = 0 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 PyObject *swig_obj[1] ;
37798
37799 if (!args) SWIG_fail;
37800 swig_obj[0] = args;
37801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37802 if (!SWIG_IsOK(res1)) {
37803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37804 }
37805 arg1 = reinterpret_cast< wxWindow * >(argp1);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 {
37813 resultobj = wxPyMake_wxObject(result, (bool)0);
37814 }
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37822 PyObject *resultobj = 0;
37823 wxWindow *arg1 = (wxWindow *) 0 ;
37824 void *argp1 = 0 ;
37825 int res1 = 0 ;
37826 PyObject *swig_obj[1] ;
37827
37828 if (!args) SWIG_fail;
37829 swig_obj[0] = args;
37830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37831 if (!SWIG_IsOK(res1)) {
37832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37833 }
37834 arg1 = reinterpret_cast< wxWindow * >(argp1);
37835 {
37836 PyThreadState* __tstate = wxPyBeginAllowThreads();
37837 (arg1)->InheritAttributes();
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 resultobj = SWIG_Py_Void();
37842 return resultobj;
37843 fail:
37844 return NULL;
37845 }
37846
37847
37848 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37849 PyObject *resultobj = 0;
37850 wxWindow *arg1 = (wxWindow *) 0 ;
37851 bool result;
37852 void *argp1 = 0 ;
37853 int res1 = 0 ;
37854 PyObject *swig_obj[1] ;
37855
37856 if (!args) SWIG_fail;
37857 swig_obj[0] = args;
37858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37859 if (!SWIG_IsOK(res1)) {
37860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37861 }
37862 arg1 = reinterpret_cast< wxWindow * >(argp1);
37863 {
37864 PyThreadState* __tstate = wxPyBeginAllowThreads();
37865 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37866 wxPyEndAllowThreads(__tstate);
37867 if (PyErr_Occurred()) SWIG_fail;
37868 }
37869 {
37870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37871 }
37872 return resultobj;
37873 fail:
37874 return NULL;
37875 }
37876
37877
37878 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37879 PyObject *resultobj = 0;
37880 wxWindow *arg1 = (wxWindow *) 0 ;
37881 bool result;
37882 void *argp1 = 0 ;
37883 int res1 = 0 ;
37884 PyObject *swig_obj[1] ;
37885
37886 if (!args) SWIG_fail;
37887 swig_obj[0] = args;
37888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37889 if (!SWIG_IsOK(res1)) {
37890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37891 }
37892 arg1 = reinterpret_cast< wxWindow * >(argp1);
37893 {
37894 PyThreadState* __tstate = wxPyBeginAllowThreads();
37895 result = (bool)(arg1)->CanSetTransparent();
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 {
37900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37901 }
37902 return resultobj;
37903 fail:
37904 return NULL;
37905 }
37906
37907
37908 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37909 PyObject *resultobj = 0;
37910 wxWindow *arg1 = (wxWindow *) 0 ;
37911 byte arg2 ;
37912 bool result;
37913 void *argp1 = 0 ;
37914 int res1 = 0 ;
37915 unsigned char val2 ;
37916 int ecode2 = 0 ;
37917 PyObject * obj0 = 0 ;
37918 PyObject * obj1 = 0 ;
37919 char * kwnames[] = {
37920 (char *) "self",(char *) "alpha", NULL
37921 };
37922
37923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37925 if (!SWIG_IsOK(res1)) {
37926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37927 }
37928 arg1 = reinterpret_cast< wxWindow * >(argp1);
37929 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37930 if (!SWIG_IsOK(ecode2)) {
37931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37932 }
37933 arg2 = static_cast< byte >(val2);
37934 {
37935 PyThreadState* __tstate = wxPyBeginAllowThreads();
37936 result = (bool)(arg1)->SetTransparent(arg2);
37937 wxPyEndAllowThreads(__tstate);
37938 if (PyErr_Occurred()) SWIG_fail;
37939 }
37940 {
37941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37942 }
37943 return resultobj;
37944 fail:
37945 return NULL;
37946 }
37947
37948
37949 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37950 PyObject *obj;
37951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37952 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37953 return SWIG_Py_Void();
37954 }
37955
37956 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37957 return SWIG_Python_InitShadowInstance(args);
37958 }
37959
37960 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37961 PyObject *resultobj = 0;
37962 long arg1 ;
37963 wxWindow *arg2 = (wxWindow *) NULL ;
37964 wxWindow *result = 0 ;
37965 long val1 ;
37966 int ecode1 = 0 ;
37967 void *argp2 = 0 ;
37968 int res2 = 0 ;
37969 PyObject * obj0 = 0 ;
37970 PyObject * obj1 = 0 ;
37971 char * kwnames[] = {
37972 (char *) "id",(char *) "parent", NULL
37973 };
37974
37975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37976 ecode1 = SWIG_AsVal_long(obj0, &val1);
37977 if (!SWIG_IsOK(ecode1)) {
37978 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37979 }
37980 arg1 = static_cast< long >(val1);
37981 if (obj1) {
37982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37983 if (!SWIG_IsOK(res2)) {
37984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37985 }
37986 arg2 = reinterpret_cast< wxWindow * >(argp2);
37987 }
37988 {
37989 if (!wxPyCheckForApp()) SWIG_fail;
37990 PyThreadState* __tstate = wxPyBeginAllowThreads();
37991 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37992 wxPyEndAllowThreads(__tstate);
37993 if (PyErr_Occurred()) SWIG_fail;
37994 }
37995 {
37996 resultobj = wxPyMake_wxObject(result, 0);
37997 }
37998 return resultobj;
37999 fail:
38000 return NULL;
38001 }
38002
38003
38004 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38005 PyObject *resultobj = 0;
38006 wxString *arg1 = 0 ;
38007 wxWindow *arg2 = (wxWindow *) NULL ;
38008 wxWindow *result = 0 ;
38009 bool temp1 = false ;
38010 void *argp2 = 0 ;
38011 int res2 = 0 ;
38012 PyObject * obj0 = 0 ;
38013 PyObject * obj1 = 0 ;
38014 char * kwnames[] = {
38015 (char *) "name",(char *) "parent", NULL
38016 };
38017
38018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38019 {
38020 arg1 = wxString_in_helper(obj0);
38021 if (arg1 == NULL) SWIG_fail;
38022 temp1 = true;
38023 }
38024 if (obj1) {
38025 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38026 if (!SWIG_IsOK(res2)) {
38027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38028 }
38029 arg2 = reinterpret_cast< wxWindow * >(argp2);
38030 }
38031 {
38032 if (!wxPyCheckForApp()) SWIG_fail;
38033 PyThreadState* __tstate = wxPyBeginAllowThreads();
38034 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38035 wxPyEndAllowThreads(__tstate);
38036 if (PyErr_Occurred()) SWIG_fail;
38037 }
38038 {
38039 resultobj = wxPyMake_wxObject(result, 0);
38040 }
38041 {
38042 if (temp1)
38043 delete arg1;
38044 }
38045 return resultobj;
38046 fail:
38047 {
38048 if (temp1)
38049 delete arg1;
38050 }
38051 return NULL;
38052 }
38053
38054
38055 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38056 PyObject *resultobj = 0;
38057 wxString *arg1 = 0 ;
38058 wxWindow *arg2 = (wxWindow *) NULL ;
38059 wxWindow *result = 0 ;
38060 bool temp1 = false ;
38061 void *argp2 = 0 ;
38062 int res2 = 0 ;
38063 PyObject * obj0 = 0 ;
38064 PyObject * obj1 = 0 ;
38065 char * kwnames[] = {
38066 (char *) "label",(char *) "parent", NULL
38067 };
38068
38069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38070 {
38071 arg1 = wxString_in_helper(obj0);
38072 if (arg1 == NULL) SWIG_fail;
38073 temp1 = true;
38074 }
38075 if (obj1) {
38076 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38077 if (!SWIG_IsOK(res2)) {
38078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38079 }
38080 arg2 = reinterpret_cast< wxWindow * >(argp2);
38081 }
38082 {
38083 if (!wxPyCheckForApp()) SWIG_fail;
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 {
38090 resultobj = wxPyMake_wxObject(result, 0);
38091 }
38092 {
38093 if (temp1)
38094 delete arg1;
38095 }
38096 return resultobj;
38097 fail:
38098 {
38099 if (temp1)
38100 delete arg1;
38101 }
38102 return NULL;
38103 }
38104
38105
38106 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38107 PyObject *resultobj = 0;
38108 wxWindow *arg1 = (wxWindow *) 0 ;
38109 unsigned long arg2 ;
38110 wxWindow *result = 0 ;
38111 void *argp1 = 0 ;
38112 int res1 = 0 ;
38113 unsigned long val2 ;
38114 int ecode2 = 0 ;
38115 PyObject * obj0 = 0 ;
38116 PyObject * obj1 = 0 ;
38117 char * kwnames[] = {
38118 (char *) "parent",(char *) "_hWnd", NULL
38119 };
38120
38121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38123 if (!SWIG_IsOK(res1)) {
38124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38125 }
38126 arg1 = reinterpret_cast< wxWindow * >(argp1);
38127 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38128 if (!SWIG_IsOK(ecode2)) {
38129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38130 }
38131 arg2 = static_cast< unsigned long >(val2);
38132 {
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 {
38139 resultobj = wxPyMake_wxObject(result, 0);
38140 }
38141 return resultobj;
38142 fail:
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38148 PyObject *resultobj = 0;
38149 PyObject *result = 0 ;
38150
38151 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38152 {
38153 PyThreadState* __tstate = wxPyBeginAllowThreads();
38154 result = (PyObject *)GetTopLevelWindows();
38155 wxPyEndAllowThreads(__tstate);
38156 if (PyErr_Occurred()) SWIG_fail;
38157 }
38158 resultobj = result;
38159 return resultobj;
38160 fail:
38161 return NULL;
38162 }
38163
38164
38165 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38166 PyObject *resultobj = 0;
38167 wxValidator *result = 0 ;
38168
38169 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38170 {
38171 PyThreadState* __tstate = wxPyBeginAllowThreads();
38172 result = (wxValidator *)new wxValidator();
38173 wxPyEndAllowThreads(__tstate);
38174 if (PyErr_Occurred()) SWIG_fail;
38175 }
38176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38177 return resultobj;
38178 fail:
38179 return NULL;
38180 }
38181
38182
38183 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38184 PyObject *resultobj = 0;
38185 wxValidator *arg1 = (wxValidator *) 0 ;
38186 wxValidator *result = 0 ;
38187 void *argp1 = 0 ;
38188 int res1 = 0 ;
38189 PyObject *swig_obj[1] ;
38190
38191 if (!args) SWIG_fail;
38192 swig_obj[0] = args;
38193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38194 if (!SWIG_IsOK(res1)) {
38195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38196 }
38197 arg1 = reinterpret_cast< wxValidator * >(argp1);
38198 {
38199 PyThreadState* __tstate = wxPyBeginAllowThreads();
38200 result = (wxValidator *)(arg1)->Clone();
38201 wxPyEndAllowThreads(__tstate);
38202 if (PyErr_Occurred()) SWIG_fail;
38203 }
38204 {
38205 resultobj = wxPyMake_wxObject(result, 0);
38206 }
38207 return resultobj;
38208 fail:
38209 return NULL;
38210 }
38211
38212
38213 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38214 PyObject *resultobj = 0;
38215 wxValidator *arg1 = (wxValidator *) 0 ;
38216 wxWindow *arg2 = (wxWindow *) 0 ;
38217 bool result;
38218 void *argp1 = 0 ;
38219 int res1 = 0 ;
38220 void *argp2 = 0 ;
38221 int res2 = 0 ;
38222 PyObject * obj0 = 0 ;
38223 PyObject * obj1 = 0 ;
38224 char * kwnames[] = {
38225 (char *) "self",(char *) "parent", NULL
38226 };
38227
38228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38230 if (!SWIG_IsOK(res1)) {
38231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38232 }
38233 arg1 = reinterpret_cast< wxValidator * >(argp1);
38234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38235 if (!SWIG_IsOK(res2)) {
38236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38237 }
38238 arg2 = reinterpret_cast< wxWindow * >(argp2);
38239 {
38240 PyThreadState* __tstate = wxPyBeginAllowThreads();
38241 result = (bool)(arg1)->Validate(arg2);
38242 wxPyEndAllowThreads(__tstate);
38243 if (PyErr_Occurred()) SWIG_fail;
38244 }
38245 {
38246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38247 }
38248 return resultobj;
38249 fail:
38250 return NULL;
38251 }
38252
38253
38254 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38255 PyObject *resultobj = 0;
38256 wxValidator *arg1 = (wxValidator *) 0 ;
38257 bool result;
38258 void *argp1 = 0 ;
38259 int res1 = 0 ;
38260 PyObject *swig_obj[1] ;
38261
38262 if (!args) SWIG_fail;
38263 swig_obj[0] = args;
38264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38265 if (!SWIG_IsOK(res1)) {
38266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38267 }
38268 arg1 = reinterpret_cast< wxValidator * >(argp1);
38269 {
38270 PyThreadState* __tstate = wxPyBeginAllowThreads();
38271 result = (bool)(arg1)->TransferToWindow();
38272 wxPyEndAllowThreads(__tstate);
38273 if (PyErr_Occurred()) SWIG_fail;
38274 }
38275 {
38276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38277 }
38278 return resultobj;
38279 fail:
38280 return NULL;
38281 }
38282
38283
38284 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38285 PyObject *resultobj = 0;
38286 wxValidator *arg1 = (wxValidator *) 0 ;
38287 bool result;
38288 void *argp1 = 0 ;
38289 int res1 = 0 ;
38290 PyObject *swig_obj[1] ;
38291
38292 if (!args) SWIG_fail;
38293 swig_obj[0] = args;
38294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38295 if (!SWIG_IsOK(res1)) {
38296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38297 }
38298 arg1 = reinterpret_cast< wxValidator * >(argp1);
38299 {
38300 PyThreadState* __tstate = wxPyBeginAllowThreads();
38301 result = (bool)(arg1)->TransferFromWindow();
38302 wxPyEndAllowThreads(__tstate);
38303 if (PyErr_Occurred()) SWIG_fail;
38304 }
38305 {
38306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38307 }
38308 return resultobj;
38309 fail:
38310 return NULL;
38311 }
38312
38313
38314 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38315 PyObject *resultobj = 0;
38316 wxValidator *arg1 = (wxValidator *) 0 ;
38317 wxWindow *result = 0 ;
38318 void *argp1 = 0 ;
38319 int res1 = 0 ;
38320 PyObject *swig_obj[1] ;
38321
38322 if (!args) SWIG_fail;
38323 swig_obj[0] = args;
38324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38325 if (!SWIG_IsOK(res1)) {
38326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38327 }
38328 arg1 = reinterpret_cast< wxValidator * >(argp1);
38329 {
38330 PyThreadState* __tstate = wxPyBeginAllowThreads();
38331 result = (wxWindow *)(arg1)->GetWindow();
38332 wxPyEndAllowThreads(__tstate);
38333 if (PyErr_Occurred()) SWIG_fail;
38334 }
38335 {
38336 resultobj = wxPyMake_wxObject(result, 0);
38337 }
38338 return resultobj;
38339 fail:
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38345 PyObject *resultobj = 0;
38346 wxValidator *arg1 = (wxValidator *) 0 ;
38347 wxWindow *arg2 = (wxWindow *) 0 ;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 void *argp2 = 0 ;
38351 int res2 = 0 ;
38352 PyObject * obj0 = 0 ;
38353 PyObject * obj1 = 0 ;
38354 char * kwnames[] = {
38355 (char *) "self",(char *) "window", NULL
38356 };
38357
38358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38360 if (!SWIG_IsOK(res1)) {
38361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38362 }
38363 arg1 = reinterpret_cast< wxValidator * >(argp1);
38364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38365 if (!SWIG_IsOK(res2)) {
38366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38367 }
38368 arg2 = reinterpret_cast< wxWindow * >(argp2);
38369 {
38370 PyThreadState* __tstate = wxPyBeginAllowThreads();
38371 (arg1)->SetWindow(arg2);
38372 wxPyEndAllowThreads(__tstate);
38373 if (PyErr_Occurred()) SWIG_fail;
38374 }
38375 resultobj = SWIG_Py_Void();
38376 return resultobj;
38377 fail:
38378 return NULL;
38379 }
38380
38381
38382 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38383 PyObject *resultobj = 0;
38384 bool result;
38385
38386 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38387 {
38388 PyThreadState* __tstate = wxPyBeginAllowThreads();
38389 result = (bool)wxValidator::IsSilent();
38390 wxPyEndAllowThreads(__tstate);
38391 if (PyErr_Occurred()) SWIG_fail;
38392 }
38393 {
38394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38395 }
38396 return resultobj;
38397 fail:
38398 return NULL;
38399 }
38400
38401
38402 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38403 PyObject *resultobj = 0;
38404 int arg1 = (int) true ;
38405 int val1 ;
38406 int ecode1 = 0 ;
38407 PyObject * obj0 = 0 ;
38408 char * kwnames[] = {
38409 (char *) "doIt", NULL
38410 };
38411
38412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38413 if (obj0) {
38414 ecode1 = SWIG_AsVal_int(obj0, &val1);
38415 if (!SWIG_IsOK(ecode1)) {
38416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38417 }
38418 arg1 = static_cast< int >(val1);
38419 }
38420 {
38421 PyThreadState* __tstate = wxPyBeginAllowThreads();
38422 wxValidator::SetBellOnError(arg1);
38423 wxPyEndAllowThreads(__tstate);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 }
38426 resultobj = SWIG_Py_Void();
38427 return resultobj;
38428 fail:
38429 return NULL;
38430 }
38431
38432
38433 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38434 PyObject *obj;
38435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38436 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38437 return SWIG_Py_Void();
38438 }
38439
38440 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38441 return SWIG_Python_InitShadowInstance(args);
38442 }
38443
38444 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38445 PyObject *resultobj = 0;
38446 wxPyValidator *result = 0 ;
38447
38448 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38449 {
38450 PyThreadState* __tstate = wxPyBeginAllowThreads();
38451 result = (wxPyValidator *)new wxPyValidator();
38452 wxPyEndAllowThreads(__tstate);
38453 if (PyErr_Occurred()) SWIG_fail;
38454 }
38455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38456 return resultobj;
38457 fail:
38458 return NULL;
38459 }
38460
38461
38462 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38463 PyObject *resultobj = 0;
38464 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38465 PyObject *arg2 = (PyObject *) 0 ;
38466 PyObject *arg3 = (PyObject *) 0 ;
38467 int arg4 = (int) true ;
38468 void *argp1 = 0 ;
38469 int res1 = 0 ;
38470 int val4 ;
38471 int ecode4 = 0 ;
38472 PyObject * obj0 = 0 ;
38473 PyObject * obj1 = 0 ;
38474 PyObject * obj2 = 0 ;
38475 PyObject * obj3 = 0 ;
38476 char * kwnames[] = {
38477 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38478 };
38479
38480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38482 if (!SWIG_IsOK(res1)) {
38483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38484 }
38485 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38486 arg2 = obj1;
38487 arg3 = obj2;
38488 if (obj3) {
38489 ecode4 = SWIG_AsVal_int(obj3, &val4);
38490 if (!SWIG_IsOK(ecode4)) {
38491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38492 }
38493 arg4 = static_cast< int >(val4);
38494 }
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38498 wxPyEndAllowThreads(__tstate);
38499 if (PyErr_Occurred()) SWIG_fail;
38500 }
38501 resultobj = SWIG_Py_Void();
38502 return resultobj;
38503 fail:
38504 return NULL;
38505 }
38506
38507
38508 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38509 PyObject *obj;
38510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38512 return SWIG_Py_Void();
38513 }
38514
38515 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38516 return SWIG_Python_InitShadowInstance(args);
38517 }
38518
38519 SWIGINTERN int DefaultValidator_set(PyObject *) {
38520 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38521 return 1;
38522 }
38523
38524
38525 SWIGINTERN PyObject *DefaultValidator_get(void) {
38526 PyObject *pyobj = 0;
38527
38528 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38529 return pyobj;
38530 }
38531
38532
38533 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38534 PyObject *resultobj = 0;
38535 wxString const &arg1_defvalue = wxPyEmptyString ;
38536 wxString *arg1 = (wxString *) &arg1_defvalue ;
38537 long arg2 = (long) 0 ;
38538 wxMenu *result = 0 ;
38539 bool temp1 = false ;
38540 long val2 ;
38541 int ecode2 = 0 ;
38542 PyObject * obj0 = 0 ;
38543 PyObject * obj1 = 0 ;
38544 char * kwnames[] = {
38545 (char *) "title",(char *) "style", NULL
38546 };
38547
38548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38549 if (obj0) {
38550 {
38551 arg1 = wxString_in_helper(obj0);
38552 if (arg1 == NULL) SWIG_fail;
38553 temp1 = true;
38554 }
38555 }
38556 if (obj1) {
38557 ecode2 = SWIG_AsVal_long(obj1, &val2);
38558 if (!SWIG_IsOK(ecode2)) {
38559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38560 }
38561 arg2 = static_cast< long >(val2);
38562 }
38563 {
38564 if (!wxPyCheckForApp()) SWIG_fail;
38565 PyThreadState* __tstate = wxPyBeginAllowThreads();
38566 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38567 wxPyEndAllowThreads(__tstate);
38568 if (PyErr_Occurred()) SWIG_fail;
38569 }
38570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38571 {
38572 if (temp1)
38573 delete arg1;
38574 }
38575 return resultobj;
38576 fail:
38577 {
38578 if (temp1)
38579 delete arg1;
38580 }
38581 return NULL;
38582 }
38583
38584
38585 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38586 PyObject *resultobj = 0;
38587 wxMenu *arg1 = (wxMenu *) 0 ;
38588 int arg2 ;
38589 wxString *arg3 = 0 ;
38590 wxString const &arg4_defvalue = wxPyEmptyString ;
38591 wxString *arg4 = (wxString *) &arg4_defvalue ;
38592 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38593 wxMenuItem *result = 0 ;
38594 void *argp1 = 0 ;
38595 int res1 = 0 ;
38596 int val2 ;
38597 int ecode2 = 0 ;
38598 bool temp3 = false ;
38599 bool temp4 = false ;
38600 int val5 ;
38601 int ecode5 = 0 ;
38602 PyObject * obj0 = 0 ;
38603 PyObject * obj1 = 0 ;
38604 PyObject * obj2 = 0 ;
38605 PyObject * obj3 = 0 ;
38606 PyObject * obj4 = 0 ;
38607 char * kwnames[] = {
38608 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38609 };
38610
38611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38613 if (!SWIG_IsOK(res1)) {
38614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38615 }
38616 arg1 = reinterpret_cast< wxMenu * >(argp1);
38617 ecode2 = SWIG_AsVal_int(obj1, &val2);
38618 if (!SWIG_IsOK(ecode2)) {
38619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38620 }
38621 arg2 = static_cast< int >(val2);
38622 {
38623 arg3 = wxString_in_helper(obj2);
38624 if (arg3 == NULL) SWIG_fail;
38625 temp3 = true;
38626 }
38627 if (obj3) {
38628 {
38629 arg4 = wxString_in_helper(obj3);
38630 if (arg4 == NULL) SWIG_fail;
38631 temp4 = true;
38632 }
38633 }
38634 if (obj4) {
38635 ecode5 = SWIG_AsVal_int(obj4, &val5);
38636 if (!SWIG_IsOK(ecode5)) {
38637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38638 }
38639 arg5 = static_cast< wxItemKind >(val5);
38640 }
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38644 wxPyEndAllowThreads(__tstate);
38645 if (PyErr_Occurred()) SWIG_fail;
38646 }
38647 {
38648 resultobj = wxPyMake_wxObject(result, (bool)0);
38649 }
38650 {
38651 if (temp3)
38652 delete arg3;
38653 }
38654 {
38655 if (temp4)
38656 delete arg4;
38657 }
38658 return resultobj;
38659 fail:
38660 {
38661 if (temp3)
38662 delete arg3;
38663 }
38664 {
38665 if (temp4)
38666 delete arg4;
38667 }
38668 return NULL;
38669 }
38670
38671
38672 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38673 PyObject *resultobj = 0;
38674 wxMenu *arg1 = (wxMenu *) 0 ;
38675 wxMenuItem *result = 0 ;
38676 void *argp1 = 0 ;
38677 int res1 = 0 ;
38678 PyObject *swig_obj[1] ;
38679
38680 if (!args) SWIG_fail;
38681 swig_obj[0] = args;
38682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38683 if (!SWIG_IsOK(res1)) {
38684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38685 }
38686 arg1 = reinterpret_cast< wxMenu * >(argp1);
38687 {
38688 PyThreadState* __tstate = wxPyBeginAllowThreads();
38689 result = (wxMenuItem *)(arg1)->AppendSeparator();
38690 wxPyEndAllowThreads(__tstate);
38691 if (PyErr_Occurred()) SWIG_fail;
38692 }
38693 {
38694 resultobj = wxPyMake_wxObject(result, (bool)0);
38695 }
38696 return resultobj;
38697 fail:
38698 return NULL;
38699 }
38700
38701
38702 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38703 PyObject *resultobj = 0;
38704 wxMenu *arg1 = (wxMenu *) 0 ;
38705 int arg2 ;
38706 wxString *arg3 = 0 ;
38707 wxString const &arg4_defvalue = wxPyEmptyString ;
38708 wxString *arg4 = (wxString *) &arg4_defvalue ;
38709 wxMenuItem *result = 0 ;
38710 void *argp1 = 0 ;
38711 int res1 = 0 ;
38712 int val2 ;
38713 int ecode2 = 0 ;
38714 bool temp3 = false ;
38715 bool temp4 = false ;
38716 PyObject * obj0 = 0 ;
38717 PyObject * obj1 = 0 ;
38718 PyObject * obj2 = 0 ;
38719 PyObject * obj3 = 0 ;
38720 char * kwnames[] = {
38721 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38722 };
38723
38724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38726 if (!SWIG_IsOK(res1)) {
38727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38728 }
38729 arg1 = reinterpret_cast< wxMenu * >(argp1);
38730 ecode2 = SWIG_AsVal_int(obj1, &val2);
38731 if (!SWIG_IsOK(ecode2)) {
38732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38733 }
38734 arg2 = static_cast< int >(val2);
38735 {
38736 arg3 = wxString_in_helper(obj2);
38737 if (arg3 == NULL) SWIG_fail;
38738 temp3 = true;
38739 }
38740 if (obj3) {
38741 {
38742 arg4 = wxString_in_helper(obj3);
38743 if (arg4 == NULL) SWIG_fail;
38744 temp4 = true;
38745 }
38746 }
38747 {
38748 PyThreadState* __tstate = wxPyBeginAllowThreads();
38749 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38750 wxPyEndAllowThreads(__tstate);
38751 if (PyErr_Occurred()) SWIG_fail;
38752 }
38753 {
38754 resultobj = wxPyMake_wxObject(result, (bool)0);
38755 }
38756 {
38757 if (temp3)
38758 delete arg3;
38759 }
38760 {
38761 if (temp4)
38762 delete arg4;
38763 }
38764 return resultobj;
38765 fail:
38766 {
38767 if (temp3)
38768 delete arg3;
38769 }
38770 {
38771 if (temp4)
38772 delete arg4;
38773 }
38774 return NULL;
38775 }
38776
38777
38778 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38779 PyObject *resultobj = 0;
38780 wxMenu *arg1 = (wxMenu *) 0 ;
38781 int arg2 ;
38782 wxString *arg3 = 0 ;
38783 wxString const &arg4_defvalue = wxPyEmptyString ;
38784 wxString *arg4 = (wxString *) &arg4_defvalue ;
38785 wxMenuItem *result = 0 ;
38786 void *argp1 = 0 ;
38787 int res1 = 0 ;
38788 int val2 ;
38789 int ecode2 = 0 ;
38790 bool temp3 = false ;
38791 bool temp4 = false ;
38792 PyObject * obj0 = 0 ;
38793 PyObject * obj1 = 0 ;
38794 PyObject * obj2 = 0 ;
38795 PyObject * obj3 = 0 ;
38796 char * kwnames[] = {
38797 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38798 };
38799
38800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38802 if (!SWIG_IsOK(res1)) {
38803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38804 }
38805 arg1 = reinterpret_cast< wxMenu * >(argp1);
38806 ecode2 = SWIG_AsVal_int(obj1, &val2);
38807 if (!SWIG_IsOK(ecode2)) {
38808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38809 }
38810 arg2 = static_cast< int >(val2);
38811 {
38812 arg3 = wxString_in_helper(obj2);
38813 if (arg3 == NULL) SWIG_fail;
38814 temp3 = true;
38815 }
38816 if (obj3) {
38817 {
38818 arg4 = wxString_in_helper(obj3);
38819 if (arg4 == NULL) SWIG_fail;
38820 temp4 = true;
38821 }
38822 }
38823 {
38824 PyThreadState* __tstate = wxPyBeginAllowThreads();
38825 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38826 wxPyEndAllowThreads(__tstate);
38827 if (PyErr_Occurred()) SWIG_fail;
38828 }
38829 {
38830 resultobj = wxPyMake_wxObject(result, (bool)0);
38831 }
38832 {
38833 if (temp3)
38834 delete arg3;
38835 }
38836 {
38837 if (temp4)
38838 delete arg4;
38839 }
38840 return resultobj;
38841 fail:
38842 {
38843 if (temp3)
38844 delete arg3;
38845 }
38846 {
38847 if (temp4)
38848 delete arg4;
38849 }
38850 return NULL;
38851 }
38852
38853
38854 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38855 PyObject *resultobj = 0;
38856 wxMenu *arg1 = (wxMenu *) 0 ;
38857 int arg2 ;
38858 wxString *arg3 = 0 ;
38859 wxMenu *arg4 = (wxMenu *) 0 ;
38860 wxString const &arg5_defvalue = wxPyEmptyString ;
38861 wxString *arg5 = (wxString *) &arg5_defvalue ;
38862 wxMenuItem *result = 0 ;
38863 void *argp1 = 0 ;
38864 int res1 = 0 ;
38865 int val2 ;
38866 int ecode2 = 0 ;
38867 bool temp3 = false ;
38868 void *argp4 = 0 ;
38869 int res4 = 0 ;
38870 bool temp5 = false ;
38871 PyObject * obj0 = 0 ;
38872 PyObject * obj1 = 0 ;
38873 PyObject * obj2 = 0 ;
38874 PyObject * obj3 = 0 ;
38875 PyObject * obj4 = 0 ;
38876 char * kwnames[] = {
38877 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38878 };
38879
38880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38882 if (!SWIG_IsOK(res1)) {
38883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38884 }
38885 arg1 = reinterpret_cast< wxMenu * >(argp1);
38886 ecode2 = SWIG_AsVal_int(obj1, &val2);
38887 if (!SWIG_IsOK(ecode2)) {
38888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38889 }
38890 arg2 = static_cast< int >(val2);
38891 {
38892 arg3 = wxString_in_helper(obj2);
38893 if (arg3 == NULL) SWIG_fail;
38894 temp3 = true;
38895 }
38896 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38897 if (!SWIG_IsOK(res4)) {
38898 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38899 }
38900 arg4 = reinterpret_cast< wxMenu * >(argp4);
38901 if (obj4) {
38902 {
38903 arg5 = wxString_in_helper(obj4);
38904 if (arg5 == NULL) SWIG_fail;
38905 temp5 = true;
38906 }
38907 }
38908 {
38909 PyThreadState* __tstate = wxPyBeginAllowThreads();
38910 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38911 wxPyEndAllowThreads(__tstate);
38912 if (PyErr_Occurred()) SWIG_fail;
38913 }
38914 {
38915 resultobj = wxPyMake_wxObject(result, (bool)0);
38916 }
38917 {
38918 if (temp3)
38919 delete arg3;
38920 }
38921 {
38922 if (temp5)
38923 delete arg5;
38924 }
38925 return resultobj;
38926 fail:
38927 {
38928 if (temp3)
38929 delete arg3;
38930 }
38931 {
38932 if (temp5)
38933 delete arg5;
38934 }
38935 return NULL;
38936 }
38937
38938
38939 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38940 PyObject *resultobj = 0;
38941 wxMenu *arg1 = (wxMenu *) 0 ;
38942 wxMenu *arg2 = (wxMenu *) 0 ;
38943 wxString *arg3 = 0 ;
38944 wxString const &arg4_defvalue = wxPyEmptyString ;
38945 wxString *arg4 = (wxString *) &arg4_defvalue ;
38946 wxMenuItem *result = 0 ;
38947 void *argp1 = 0 ;
38948 int res1 = 0 ;
38949 void *argp2 = 0 ;
38950 int res2 = 0 ;
38951 bool temp3 = false ;
38952 bool temp4 = false ;
38953 PyObject * obj0 = 0 ;
38954 PyObject * obj1 = 0 ;
38955 PyObject * obj2 = 0 ;
38956 PyObject * obj3 = 0 ;
38957 char * kwnames[] = {
38958 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38959 };
38960
38961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38963 if (!SWIG_IsOK(res1)) {
38964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38965 }
38966 arg1 = reinterpret_cast< wxMenu * >(argp1);
38967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38968 if (!SWIG_IsOK(res2)) {
38969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38970 }
38971 arg2 = reinterpret_cast< wxMenu * >(argp2);
38972 {
38973 arg3 = wxString_in_helper(obj2);
38974 if (arg3 == NULL) SWIG_fail;
38975 temp3 = true;
38976 }
38977 if (obj3) {
38978 {
38979 arg4 = wxString_in_helper(obj3);
38980 if (arg4 == NULL) SWIG_fail;
38981 temp4 = true;
38982 }
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = wxPyMake_wxObject(result, (bool)0);
38992 }
38993 {
38994 if (temp3)
38995 delete arg3;
38996 }
38997 {
38998 if (temp4)
38999 delete arg4;
39000 }
39001 return resultobj;
39002 fail:
39003 {
39004 if (temp3)
39005 delete arg3;
39006 }
39007 {
39008 if (temp4)
39009 delete arg4;
39010 }
39011 return NULL;
39012 }
39013
39014
39015 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39016 PyObject *resultobj = 0;
39017 wxMenu *arg1 = (wxMenu *) 0 ;
39018 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39019 wxMenuItem *result = 0 ;
39020 void *argp1 = 0 ;
39021 int res1 = 0 ;
39022 int res2 = 0 ;
39023 PyObject * obj0 = 0 ;
39024 PyObject * obj1 = 0 ;
39025 char * kwnames[] = {
39026 (char *) "self",(char *) "item", NULL
39027 };
39028
39029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39031 if (!SWIG_IsOK(res1)) {
39032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39033 }
39034 arg1 = reinterpret_cast< wxMenu * >(argp1);
39035 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39036 if (!SWIG_IsOK(res2)) {
39037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39038 }
39039 {
39040 PyThreadState* __tstate = wxPyBeginAllowThreads();
39041 result = (wxMenuItem *)(arg1)->Append(arg2);
39042 wxPyEndAllowThreads(__tstate);
39043 if (PyErr_Occurred()) SWIG_fail;
39044 }
39045 {
39046 resultobj = wxPyMake_wxObject(result, (bool)0);
39047 }
39048 return resultobj;
39049 fail:
39050 return NULL;
39051 }
39052
39053
39054 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39055 PyObject *resultobj = 0;
39056 wxMenu *arg1 = (wxMenu *) 0 ;
39057 size_t arg2 ;
39058 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39059 wxMenuItem *result = 0 ;
39060 void *argp1 = 0 ;
39061 int res1 = 0 ;
39062 size_t val2 ;
39063 int ecode2 = 0 ;
39064 int res3 = 0 ;
39065 PyObject * obj0 = 0 ;
39066 PyObject * obj1 = 0 ;
39067 PyObject * obj2 = 0 ;
39068 char * kwnames[] = {
39069 (char *) "self",(char *) "pos",(char *) "item", NULL
39070 };
39071
39072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39074 if (!SWIG_IsOK(res1)) {
39075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39076 }
39077 arg1 = reinterpret_cast< wxMenu * >(argp1);
39078 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39079 if (!SWIG_IsOK(ecode2)) {
39080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39081 }
39082 arg2 = static_cast< size_t >(val2);
39083 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39084 if (!SWIG_IsOK(res3)) {
39085 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39086 }
39087 {
39088 PyThreadState* __tstate = wxPyBeginAllowThreads();
39089 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39090 wxPyEndAllowThreads(__tstate);
39091 if (PyErr_Occurred()) SWIG_fail;
39092 }
39093 {
39094 resultobj = wxPyMake_wxObject(result, (bool)0);
39095 }
39096 return resultobj;
39097 fail:
39098 return NULL;
39099 }
39100
39101
39102 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39103 PyObject *resultobj = 0;
39104 wxMenu *arg1 = (wxMenu *) 0 ;
39105 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39106 wxMenuItem *result = 0 ;
39107 void *argp1 = 0 ;
39108 int res1 = 0 ;
39109 int res2 = 0 ;
39110 PyObject * obj0 = 0 ;
39111 PyObject * obj1 = 0 ;
39112 char * kwnames[] = {
39113 (char *) "self",(char *) "item", NULL
39114 };
39115
39116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39118 if (!SWIG_IsOK(res1)) {
39119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39120 }
39121 arg1 = reinterpret_cast< wxMenu * >(argp1);
39122 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39123 if (!SWIG_IsOK(res2)) {
39124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39125 }
39126 {
39127 PyThreadState* __tstate = wxPyBeginAllowThreads();
39128 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39129 wxPyEndAllowThreads(__tstate);
39130 if (PyErr_Occurred()) SWIG_fail;
39131 }
39132 {
39133 resultobj = wxPyMake_wxObject(result, (bool)0);
39134 }
39135 return resultobj;
39136 fail:
39137 return NULL;
39138 }
39139
39140
39141 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39142 PyObject *resultobj = 0;
39143 wxMenu *arg1 = (wxMenu *) 0 ;
39144 void *argp1 = 0 ;
39145 int res1 = 0 ;
39146 PyObject *swig_obj[1] ;
39147
39148 if (!args) SWIG_fail;
39149 swig_obj[0] = args;
39150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39151 if (!SWIG_IsOK(res1)) {
39152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39153 }
39154 arg1 = reinterpret_cast< wxMenu * >(argp1);
39155 {
39156 PyThreadState* __tstate = wxPyBeginAllowThreads();
39157 (arg1)->Break();
39158 wxPyEndAllowThreads(__tstate);
39159 if (PyErr_Occurred()) SWIG_fail;
39160 }
39161 resultobj = SWIG_Py_Void();
39162 return resultobj;
39163 fail:
39164 return NULL;
39165 }
39166
39167
39168 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39169 PyObject *resultobj = 0;
39170 wxMenu *arg1 = (wxMenu *) 0 ;
39171 size_t arg2 ;
39172 int arg3 ;
39173 wxString *arg4 = 0 ;
39174 wxString const &arg5_defvalue = wxPyEmptyString ;
39175 wxString *arg5 = (wxString *) &arg5_defvalue ;
39176 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39177 wxMenuItem *result = 0 ;
39178 void *argp1 = 0 ;
39179 int res1 = 0 ;
39180 size_t val2 ;
39181 int ecode2 = 0 ;
39182 int val3 ;
39183 int ecode3 = 0 ;
39184 bool temp4 = false ;
39185 bool temp5 = false ;
39186 int val6 ;
39187 int ecode6 = 0 ;
39188 PyObject * obj0 = 0 ;
39189 PyObject * obj1 = 0 ;
39190 PyObject * obj2 = 0 ;
39191 PyObject * obj3 = 0 ;
39192 PyObject * obj4 = 0 ;
39193 PyObject * obj5 = 0 ;
39194 char * kwnames[] = {
39195 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39196 };
39197
39198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39200 if (!SWIG_IsOK(res1)) {
39201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39202 }
39203 arg1 = reinterpret_cast< wxMenu * >(argp1);
39204 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39205 if (!SWIG_IsOK(ecode2)) {
39206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39207 }
39208 arg2 = static_cast< size_t >(val2);
39209 ecode3 = SWIG_AsVal_int(obj2, &val3);
39210 if (!SWIG_IsOK(ecode3)) {
39211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39212 }
39213 arg3 = static_cast< int >(val3);
39214 {
39215 arg4 = wxString_in_helper(obj3);
39216 if (arg4 == NULL) SWIG_fail;
39217 temp4 = true;
39218 }
39219 if (obj4) {
39220 {
39221 arg5 = wxString_in_helper(obj4);
39222 if (arg5 == NULL) SWIG_fail;
39223 temp5 = true;
39224 }
39225 }
39226 if (obj5) {
39227 ecode6 = SWIG_AsVal_int(obj5, &val6);
39228 if (!SWIG_IsOK(ecode6)) {
39229 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39230 }
39231 arg6 = static_cast< wxItemKind >(val6);
39232 }
39233 {
39234 PyThreadState* __tstate = wxPyBeginAllowThreads();
39235 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39236 wxPyEndAllowThreads(__tstate);
39237 if (PyErr_Occurred()) SWIG_fail;
39238 }
39239 {
39240 resultobj = wxPyMake_wxObject(result, (bool)0);
39241 }
39242 {
39243 if (temp4)
39244 delete arg4;
39245 }
39246 {
39247 if (temp5)
39248 delete arg5;
39249 }
39250 return resultobj;
39251 fail:
39252 {
39253 if (temp4)
39254 delete arg4;
39255 }
39256 {
39257 if (temp5)
39258 delete arg5;
39259 }
39260 return NULL;
39261 }
39262
39263
39264 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39265 PyObject *resultobj = 0;
39266 wxMenu *arg1 = (wxMenu *) 0 ;
39267 size_t arg2 ;
39268 wxMenuItem *result = 0 ;
39269 void *argp1 = 0 ;
39270 int res1 = 0 ;
39271 size_t val2 ;
39272 int ecode2 = 0 ;
39273 PyObject * obj0 = 0 ;
39274 PyObject * obj1 = 0 ;
39275 char * kwnames[] = {
39276 (char *) "self",(char *) "pos", NULL
39277 };
39278
39279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39281 if (!SWIG_IsOK(res1)) {
39282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39283 }
39284 arg1 = reinterpret_cast< wxMenu * >(argp1);
39285 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39286 if (!SWIG_IsOK(ecode2)) {
39287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39288 }
39289 arg2 = static_cast< size_t >(val2);
39290 {
39291 PyThreadState* __tstate = wxPyBeginAllowThreads();
39292 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39293 wxPyEndAllowThreads(__tstate);
39294 if (PyErr_Occurred()) SWIG_fail;
39295 }
39296 {
39297 resultobj = wxPyMake_wxObject(result, (bool)0);
39298 }
39299 return resultobj;
39300 fail:
39301 return NULL;
39302 }
39303
39304
39305 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39306 PyObject *resultobj = 0;
39307 wxMenu *arg1 = (wxMenu *) 0 ;
39308 size_t arg2 ;
39309 int arg3 ;
39310 wxString *arg4 = 0 ;
39311 wxString const &arg5_defvalue = wxPyEmptyString ;
39312 wxString *arg5 = (wxString *) &arg5_defvalue ;
39313 wxMenuItem *result = 0 ;
39314 void *argp1 = 0 ;
39315 int res1 = 0 ;
39316 size_t val2 ;
39317 int ecode2 = 0 ;
39318 int val3 ;
39319 int ecode3 = 0 ;
39320 bool temp4 = false ;
39321 bool temp5 = false ;
39322 PyObject * obj0 = 0 ;
39323 PyObject * obj1 = 0 ;
39324 PyObject * obj2 = 0 ;
39325 PyObject * obj3 = 0 ;
39326 PyObject * obj4 = 0 ;
39327 char * kwnames[] = {
39328 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39329 };
39330
39331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39333 if (!SWIG_IsOK(res1)) {
39334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39335 }
39336 arg1 = reinterpret_cast< wxMenu * >(argp1);
39337 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39338 if (!SWIG_IsOK(ecode2)) {
39339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39340 }
39341 arg2 = static_cast< size_t >(val2);
39342 ecode3 = SWIG_AsVal_int(obj2, &val3);
39343 if (!SWIG_IsOK(ecode3)) {
39344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39345 }
39346 arg3 = static_cast< int >(val3);
39347 {
39348 arg4 = wxString_in_helper(obj3);
39349 if (arg4 == NULL) SWIG_fail;
39350 temp4 = true;
39351 }
39352 if (obj4) {
39353 {
39354 arg5 = wxString_in_helper(obj4);
39355 if (arg5 == NULL) SWIG_fail;
39356 temp5 = true;
39357 }
39358 }
39359 {
39360 PyThreadState* __tstate = wxPyBeginAllowThreads();
39361 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39362 wxPyEndAllowThreads(__tstate);
39363 if (PyErr_Occurred()) SWIG_fail;
39364 }
39365 {
39366 resultobj = wxPyMake_wxObject(result, (bool)0);
39367 }
39368 {
39369 if (temp4)
39370 delete arg4;
39371 }
39372 {
39373 if (temp5)
39374 delete arg5;
39375 }
39376 return resultobj;
39377 fail:
39378 {
39379 if (temp4)
39380 delete arg4;
39381 }
39382 {
39383 if (temp5)
39384 delete arg5;
39385 }
39386 return NULL;
39387 }
39388
39389
39390 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39391 PyObject *resultobj = 0;
39392 wxMenu *arg1 = (wxMenu *) 0 ;
39393 size_t arg2 ;
39394 int arg3 ;
39395 wxString *arg4 = 0 ;
39396 wxString const &arg5_defvalue = wxPyEmptyString ;
39397 wxString *arg5 = (wxString *) &arg5_defvalue ;
39398 wxMenuItem *result = 0 ;
39399 void *argp1 = 0 ;
39400 int res1 = 0 ;
39401 size_t val2 ;
39402 int ecode2 = 0 ;
39403 int val3 ;
39404 int ecode3 = 0 ;
39405 bool temp4 = false ;
39406 bool temp5 = false ;
39407 PyObject * obj0 = 0 ;
39408 PyObject * obj1 = 0 ;
39409 PyObject * obj2 = 0 ;
39410 PyObject * obj3 = 0 ;
39411 PyObject * obj4 = 0 ;
39412 char * kwnames[] = {
39413 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39414 };
39415
39416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39418 if (!SWIG_IsOK(res1)) {
39419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39420 }
39421 arg1 = reinterpret_cast< wxMenu * >(argp1);
39422 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39423 if (!SWIG_IsOK(ecode2)) {
39424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39425 }
39426 arg2 = static_cast< size_t >(val2);
39427 ecode3 = SWIG_AsVal_int(obj2, &val3);
39428 if (!SWIG_IsOK(ecode3)) {
39429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39430 }
39431 arg3 = static_cast< int >(val3);
39432 {
39433 arg4 = wxString_in_helper(obj3);
39434 if (arg4 == NULL) SWIG_fail;
39435 temp4 = true;
39436 }
39437 if (obj4) {
39438 {
39439 arg5 = wxString_in_helper(obj4);
39440 if (arg5 == NULL) SWIG_fail;
39441 temp5 = true;
39442 }
39443 }
39444 {
39445 PyThreadState* __tstate = wxPyBeginAllowThreads();
39446 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39447 wxPyEndAllowThreads(__tstate);
39448 if (PyErr_Occurred()) SWIG_fail;
39449 }
39450 {
39451 resultobj = wxPyMake_wxObject(result, (bool)0);
39452 }
39453 {
39454 if (temp4)
39455 delete arg4;
39456 }
39457 {
39458 if (temp5)
39459 delete arg5;
39460 }
39461 return resultobj;
39462 fail:
39463 {
39464 if (temp4)
39465 delete arg4;
39466 }
39467 {
39468 if (temp5)
39469 delete arg5;
39470 }
39471 return NULL;
39472 }
39473
39474
39475 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39476 PyObject *resultobj = 0;
39477 wxMenu *arg1 = (wxMenu *) 0 ;
39478 size_t arg2 ;
39479 int arg3 ;
39480 wxString *arg4 = 0 ;
39481 wxMenu *arg5 = (wxMenu *) 0 ;
39482 wxString const &arg6_defvalue = wxPyEmptyString ;
39483 wxString *arg6 = (wxString *) &arg6_defvalue ;
39484 wxMenuItem *result = 0 ;
39485 void *argp1 = 0 ;
39486 int res1 = 0 ;
39487 size_t val2 ;
39488 int ecode2 = 0 ;
39489 int val3 ;
39490 int ecode3 = 0 ;
39491 bool temp4 = false ;
39492 void *argp5 = 0 ;
39493 int res5 = 0 ;
39494 bool temp6 = false ;
39495 PyObject * obj0 = 0 ;
39496 PyObject * obj1 = 0 ;
39497 PyObject * obj2 = 0 ;
39498 PyObject * obj3 = 0 ;
39499 PyObject * obj4 = 0 ;
39500 PyObject * obj5 = 0 ;
39501 char * kwnames[] = {
39502 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39503 };
39504
39505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39507 if (!SWIG_IsOK(res1)) {
39508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39509 }
39510 arg1 = reinterpret_cast< wxMenu * >(argp1);
39511 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39512 if (!SWIG_IsOK(ecode2)) {
39513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39514 }
39515 arg2 = static_cast< size_t >(val2);
39516 ecode3 = SWIG_AsVal_int(obj2, &val3);
39517 if (!SWIG_IsOK(ecode3)) {
39518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39519 }
39520 arg3 = static_cast< int >(val3);
39521 {
39522 arg4 = wxString_in_helper(obj3);
39523 if (arg4 == NULL) SWIG_fail;
39524 temp4 = true;
39525 }
39526 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39527 if (!SWIG_IsOK(res5)) {
39528 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39529 }
39530 arg5 = reinterpret_cast< wxMenu * >(argp5);
39531 if (obj5) {
39532 {
39533 arg6 = wxString_in_helper(obj5);
39534 if (arg6 == NULL) SWIG_fail;
39535 temp6 = true;
39536 }
39537 }
39538 {
39539 PyThreadState* __tstate = wxPyBeginAllowThreads();
39540 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39541 wxPyEndAllowThreads(__tstate);
39542 if (PyErr_Occurred()) SWIG_fail;
39543 }
39544 {
39545 resultobj = wxPyMake_wxObject(result, (bool)0);
39546 }
39547 {
39548 if (temp4)
39549 delete arg4;
39550 }
39551 {
39552 if (temp6)
39553 delete arg6;
39554 }
39555 return resultobj;
39556 fail:
39557 {
39558 if (temp4)
39559 delete arg4;
39560 }
39561 {
39562 if (temp6)
39563 delete arg6;
39564 }
39565 return NULL;
39566 }
39567
39568
39569 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39570 PyObject *resultobj = 0;
39571 wxMenu *arg1 = (wxMenu *) 0 ;
39572 int arg2 ;
39573 wxString *arg3 = 0 ;
39574 wxString const &arg4_defvalue = wxPyEmptyString ;
39575 wxString *arg4 = (wxString *) &arg4_defvalue ;
39576 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39577 wxMenuItem *result = 0 ;
39578 void *argp1 = 0 ;
39579 int res1 = 0 ;
39580 int val2 ;
39581 int ecode2 = 0 ;
39582 bool temp3 = false ;
39583 bool temp4 = false ;
39584 int val5 ;
39585 int ecode5 = 0 ;
39586 PyObject * obj0 = 0 ;
39587 PyObject * obj1 = 0 ;
39588 PyObject * obj2 = 0 ;
39589 PyObject * obj3 = 0 ;
39590 PyObject * obj4 = 0 ;
39591 char * kwnames[] = {
39592 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39593 };
39594
39595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39597 if (!SWIG_IsOK(res1)) {
39598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39599 }
39600 arg1 = reinterpret_cast< wxMenu * >(argp1);
39601 ecode2 = SWIG_AsVal_int(obj1, &val2);
39602 if (!SWIG_IsOK(ecode2)) {
39603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39604 }
39605 arg2 = static_cast< int >(val2);
39606 {
39607 arg3 = wxString_in_helper(obj2);
39608 if (arg3 == NULL) SWIG_fail;
39609 temp3 = true;
39610 }
39611 if (obj3) {
39612 {
39613 arg4 = wxString_in_helper(obj3);
39614 if (arg4 == NULL) SWIG_fail;
39615 temp4 = true;
39616 }
39617 }
39618 if (obj4) {
39619 ecode5 = SWIG_AsVal_int(obj4, &val5);
39620 if (!SWIG_IsOK(ecode5)) {
39621 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39622 }
39623 arg5 = static_cast< wxItemKind >(val5);
39624 }
39625 {
39626 PyThreadState* __tstate = wxPyBeginAllowThreads();
39627 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39628 wxPyEndAllowThreads(__tstate);
39629 if (PyErr_Occurred()) SWIG_fail;
39630 }
39631 {
39632 resultobj = wxPyMake_wxObject(result, (bool)0);
39633 }
39634 {
39635 if (temp3)
39636 delete arg3;
39637 }
39638 {
39639 if (temp4)
39640 delete arg4;
39641 }
39642 return resultobj;
39643 fail:
39644 {
39645 if (temp3)
39646 delete arg3;
39647 }
39648 {
39649 if (temp4)
39650 delete arg4;
39651 }
39652 return NULL;
39653 }
39654
39655
39656 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39657 PyObject *resultobj = 0;
39658 wxMenu *arg1 = (wxMenu *) 0 ;
39659 wxMenuItem *result = 0 ;
39660 void *argp1 = 0 ;
39661 int res1 = 0 ;
39662 PyObject *swig_obj[1] ;
39663
39664 if (!args) SWIG_fail;
39665 swig_obj[0] = args;
39666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39667 if (!SWIG_IsOK(res1)) {
39668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39669 }
39670 arg1 = reinterpret_cast< wxMenu * >(argp1);
39671 {
39672 PyThreadState* __tstate = wxPyBeginAllowThreads();
39673 result = (wxMenuItem *)(arg1)->PrependSeparator();
39674 wxPyEndAllowThreads(__tstate);
39675 if (PyErr_Occurred()) SWIG_fail;
39676 }
39677 {
39678 resultobj = wxPyMake_wxObject(result, (bool)0);
39679 }
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39687 PyObject *resultobj = 0;
39688 wxMenu *arg1 = (wxMenu *) 0 ;
39689 int arg2 ;
39690 wxString *arg3 = 0 ;
39691 wxString const &arg4_defvalue = wxPyEmptyString ;
39692 wxString *arg4 = (wxString *) &arg4_defvalue ;
39693 wxMenuItem *result = 0 ;
39694 void *argp1 = 0 ;
39695 int res1 = 0 ;
39696 int val2 ;
39697 int ecode2 = 0 ;
39698 bool temp3 = false ;
39699 bool temp4 = false ;
39700 PyObject * obj0 = 0 ;
39701 PyObject * obj1 = 0 ;
39702 PyObject * obj2 = 0 ;
39703 PyObject * obj3 = 0 ;
39704 char * kwnames[] = {
39705 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39706 };
39707
39708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39710 if (!SWIG_IsOK(res1)) {
39711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39712 }
39713 arg1 = reinterpret_cast< wxMenu * >(argp1);
39714 ecode2 = SWIG_AsVal_int(obj1, &val2);
39715 if (!SWIG_IsOK(ecode2)) {
39716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39717 }
39718 arg2 = static_cast< int >(val2);
39719 {
39720 arg3 = wxString_in_helper(obj2);
39721 if (arg3 == NULL) SWIG_fail;
39722 temp3 = true;
39723 }
39724 if (obj3) {
39725 {
39726 arg4 = wxString_in_helper(obj3);
39727 if (arg4 == NULL) SWIG_fail;
39728 temp4 = true;
39729 }
39730 }
39731 {
39732 PyThreadState* __tstate = wxPyBeginAllowThreads();
39733 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39734 wxPyEndAllowThreads(__tstate);
39735 if (PyErr_Occurred()) SWIG_fail;
39736 }
39737 {
39738 resultobj = wxPyMake_wxObject(result, (bool)0);
39739 }
39740 {
39741 if (temp3)
39742 delete arg3;
39743 }
39744 {
39745 if (temp4)
39746 delete arg4;
39747 }
39748 return resultobj;
39749 fail:
39750 {
39751 if (temp3)
39752 delete arg3;
39753 }
39754 {
39755 if (temp4)
39756 delete arg4;
39757 }
39758 return NULL;
39759 }
39760
39761
39762 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj = 0;
39764 wxMenu *arg1 = (wxMenu *) 0 ;
39765 int arg2 ;
39766 wxString *arg3 = 0 ;
39767 wxString const &arg4_defvalue = wxPyEmptyString ;
39768 wxString *arg4 = (wxString *) &arg4_defvalue ;
39769 wxMenuItem *result = 0 ;
39770 void *argp1 = 0 ;
39771 int res1 = 0 ;
39772 int val2 ;
39773 int ecode2 = 0 ;
39774 bool temp3 = false ;
39775 bool temp4 = false ;
39776 PyObject * obj0 = 0 ;
39777 PyObject * obj1 = 0 ;
39778 PyObject * obj2 = 0 ;
39779 PyObject * obj3 = 0 ;
39780 char * kwnames[] = {
39781 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39782 };
39783
39784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39786 if (!SWIG_IsOK(res1)) {
39787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39788 }
39789 arg1 = reinterpret_cast< wxMenu * >(argp1);
39790 ecode2 = SWIG_AsVal_int(obj1, &val2);
39791 if (!SWIG_IsOK(ecode2)) {
39792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39793 }
39794 arg2 = static_cast< int >(val2);
39795 {
39796 arg3 = wxString_in_helper(obj2);
39797 if (arg3 == NULL) SWIG_fail;
39798 temp3 = true;
39799 }
39800 if (obj3) {
39801 {
39802 arg4 = wxString_in_helper(obj3);
39803 if (arg4 == NULL) SWIG_fail;
39804 temp4 = true;
39805 }
39806 }
39807 {
39808 PyThreadState* __tstate = wxPyBeginAllowThreads();
39809 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39810 wxPyEndAllowThreads(__tstate);
39811 if (PyErr_Occurred()) SWIG_fail;
39812 }
39813 {
39814 resultobj = wxPyMake_wxObject(result, (bool)0);
39815 }
39816 {
39817 if (temp3)
39818 delete arg3;
39819 }
39820 {
39821 if (temp4)
39822 delete arg4;
39823 }
39824 return resultobj;
39825 fail:
39826 {
39827 if (temp3)
39828 delete arg3;
39829 }
39830 {
39831 if (temp4)
39832 delete arg4;
39833 }
39834 return NULL;
39835 }
39836
39837
39838 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39839 PyObject *resultobj = 0;
39840 wxMenu *arg1 = (wxMenu *) 0 ;
39841 int arg2 ;
39842 wxString *arg3 = 0 ;
39843 wxMenu *arg4 = (wxMenu *) 0 ;
39844 wxString const &arg5_defvalue = wxPyEmptyString ;
39845 wxString *arg5 = (wxString *) &arg5_defvalue ;
39846 wxMenuItem *result = 0 ;
39847 void *argp1 = 0 ;
39848 int res1 = 0 ;
39849 int val2 ;
39850 int ecode2 = 0 ;
39851 bool temp3 = false ;
39852 void *argp4 = 0 ;
39853 int res4 = 0 ;
39854 bool temp5 = false ;
39855 PyObject * obj0 = 0 ;
39856 PyObject * obj1 = 0 ;
39857 PyObject * obj2 = 0 ;
39858 PyObject * obj3 = 0 ;
39859 PyObject * obj4 = 0 ;
39860 char * kwnames[] = {
39861 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39862 };
39863
39864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39866 if (!SWIG_IsOK(res1)) {
39867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39868 }
39869 arg1 = reinterpret_cast< wxMenu * >(argp1);
39870 ecode2 = SWIG_AsVal_int(obj1, &val2);
39871 if (!SWIG_IsOK(ecode2)) {
39872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39873 }
39874 arg2 = static_cast< int >(val2);
39875 {
39876 arg3 = wxString_in_helper(obj2);
39877 if (arg3 == NULL) SWIG_fail;
39878 temp3 = true;
39879 }
39880 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39881 if (!SWIG_IsOK(res4)) {
39882 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39883 }
39884 arg4 = reinterpret_cast< wxMenu * >(argp4);
39885 if (obj4) {
39886 {
39887 arg5 = wxString_in_helper(obj4);
39888 if (arg5 == NULL) SWIG_fail;
39889 temp5 = true;
39890 }
39891 }
39892 {
39893 PyThreadState* __tstate = wxPyBeginAllowThreads();
39894 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39895 wxPyEndAllowThreads(__tstate);
39896 if (PyErr_Occurred()) SWIG_fail;
39897 }
39898 {
39899 resultobj = wxPyMake_wxObject(result, (bool)0);
39900 }
39901 {
39902 if (temp3)
39903 delete arg3;
39904 }
39905 {
39906 if (temp5)
39907 delete arg5;
39908 }
39909 return resultobj;
39910 fail:
39911 {
39912 if (temp3)
39913 delete arg3;
39914 }
39915 {
39916 if (temp5)
39917 delete arg5;
39918 }
39919 return NULL;
39920 }
39921
39922
39923 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39924 PyObject *resultobj = 0;
39925 wxMenu *arg1 = (wxMenu *) 0 ;
39926 int arg2 ;
39927 wxMenuItem *result = 0 ;
39928 void *argp1 = 0 ;
39929 int res1 = 0 ;
39930 int val2 ;
39931 int ecode2 = 0 ;
39932 PyObject * obj0 = 0 ;
39933 PyObject * obj1 = 0 ;
39934 char * kwnames[] = {
39935 (char *) "self",(char *) "id", NULL
39936 };
39937
39938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39940 if (!SWIG_IsOK(res1)) {
39941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39942 }
39943 arg1 = reinterpret_cast< wxMenu * >(argp1);
39944 ecode2 = SWIG_AsVal_int(obj1, &val2);
39945 if (!SWIG_IsOK(ecode2)) {
39946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39947 }
39948 arg2 = static_cast< int >(val2);
39949 {
39950 PyThreadState* __tstate = wxPyBeginAllowThreads();
39951 result = (wxMenuItem *)(arg1)->Remove(arg2);
39952 wxPyEndAllowThreads(__tstate);
39953 if (PyErr_Occurred()) SWIG_fail;
39954 }
39955 {
39956 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39957 }
39958 return resultobj;
39959 fail:
39960 return NULL;
39961 }
39962
39963
39964 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39965 PyObject *resultobj = 0;
39966 wxMenu *arg1 = (wxMenu *) 0 ;
39967 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39968 wxMenuItem *result = 0 ;
39969 void *argp1 = 0 ;
39970 int res1 = 0 ;
39971 void *argp2 = 0 ;
39972 int res2 = 0 ;
39973 PyObject * obj0 = 0 ;
39974 PyObject * obj1 = 0 ;
39975 char * kwnames[] = {
39976 (char *) "self",(char *) "item", NULL
39977 };
39978
39979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39981 if (!SWIG_IsOK(res1)) {
39982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39983 }
39984 arg1 = reinterpret_cast< wxMenu * >(argp1);
39985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39986 if (!SWIG_IsOK(res2)) {
39987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39988 }
39989 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39990 {
39991 PyThreadState* __tstate = wxPyBeginAllowThreads();
39992 result = (wxMenuItem *)(arg1)->Remove(arg2);
39993 wxPyEndAllowThreads(__tstate);
39994 if (PyErr_Occurred()) SWIG_fail;
39995 }
39996 {
39997 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39998 }
39999 return resultobj;
40000 fail:
40001 return NULL;
40002 }
40003
40004
40005 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40006 PyObject *resultobj = 0;
40007 wxMenu *arg1 = (wxMenu *) 0 ;
40008 int arg2 ;
40009 bool result;
40010 void *argp1 = 0 ;
40011 int res1 = 0 ;
40012 int val2 ;
40013 int ecode2 = 0 ;
40014 PyObject * obj0 = 0 ;
40015 PyObject * obj1 = 0 ;
40016 char * kwnames[] = {
40017 (char *) "self",(char *) "id", NULL
40018 };
40019
40020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40022 if (!SWIG_IsOK(res1)) {
40023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40024 }
40025 arg1 = reinterpret_cast< wxMenu * >(argp1);
40026 ecode2 = SWIG_AsVal_int(obj1, &val2);
40027 if (!SWIG_IsOK(ecode2)) {
40028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40029 }
40030 arg2 = static_cast< int >(val2);
40031 {
40032 PyThreadState* __tstate = wxPyBeginAllowThreads();
40033 result = (bool)(arg1)->Delete(arg2);
40034 wxPyEndAllowThreads(__tstate);
40035 if (PyErr_Occurred()) SWIG_fail;
40036 }
40037 {
40038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40039 }
40040 return resultobj;
40041 fail:
40042 return NULL;
40043 }
40044
40045
40046 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40047 PyObject *resultobj = 0;
40048 wxMenu *arg1 = (wxMenu *) 0 ;
40049 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40050 bool result;
40051 void *argp1 = 0 ;
40052 int res1 = 0 ;
40053 void *argp2 = 0 ;
40054 int res2 = 0 ;
40055 PyObject * obj0 = 0 ;
40056 PyObject * obj1 = 0 ;
40057 char * kwnames[] = {
40058 (char *) "self",(char *) "item", NULL
40059 };
40060
40061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40063 if (!SWIG_IsOK(res1)) {
40064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40065 }
40066 arg1 = reinterpret_cast< wxMenu * >(argp1);
40067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40068 if (!SWIG_IsOK(res2)) {
40069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40070 }
40071 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 result = (bool)(arg1)->Delete(arg2);
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 {
40079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40080 }
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40088 PyObject *resultobj = 0;
40089 wxMenu *arg1 = (wxMenu *) 0 ;
40090 void *argp1 = 0 ;
40091 int res1 = 0 ;
40092 PyObject *swig_obj[1] ;
40093
40094 if (!args) SWIG_fail;
40095 swig_obj[0] = args;
40096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40097 if (!SWIG_IsOK(res1)) {
40098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40099 }
40100 arg1 = reinterpret_cast< wxMenu * >(argp1);
40101 {
40102 PyThreadState* __tstate = wxPyBeginAllowThreads();
40103 wxMenu_Destroy(arg1);
40104 wxPyEndAllowThreads(__tstate);
40105 if (PyErr_Occurred()) SWIG_fail;
40106 }
40107 resultobj = SWIG_Py_Void();
40108 return resultobj;
40109 fail:
40110 return NULL;
40111 }
40112
40113
40114 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40115 PyObject *resultobj = 0;
40116 wxMenu *arg1 = (wxMenu *) 0 ;
40117 int arg2 ;
40118 bool result;
40119 void *argp1 = 0 ;
40120 int res1 = 0 ;
40121 int val2 ;
40122 int ecode2 = 0 ;
40123 PyObject * obj0 = 0 ;
40124 PyObject * obj1 = 0 ;
40125 char * kwnames[] = {
40126 (char *) "self",(char *) "id", NULL
40127 };
40128
40129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40131 if (!SWIG_IsOK(res1)) {
40132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40133 }
40134 arg1 = reinterpret_cast< wxMenu * >(argp1);
40135 ecode2 = SWIG_AsVal_int(obj1, &val2);
40136 if (!SWIG_IsOK(ecode2)) {
40137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40138 }
40139 arg2 = static_cast< int >(val2);
40140 {
40141 PyThreadState* __tstate = wxPyBeginAllowThreads();
40142 result = (bool)(arg1)->Destroy(arg2);
40143 wxPyEndAllowThreads(__tstate);
40144 if (PyErr_Occurred()) SWIG_fail;
40145 }
40146 {
40147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40148 }
40149 return resultobj;
40150 fail:
40151 return NULL;
40152 }
40153
40154
40155 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40156 PyObject *resultobj = 0;
40157 wxMenu *arg1 = (wxMenu *) 0 ;
40158 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40159 bool result;
40160 void *argp1 = 0 ;
40161 int res1 = 0 ;
40162 void *argp2 = 0 ;
40163 int res2 = 0 ;
40164 PyObject * obj0 = 0 ;
40165 PyObject * obj1 = 0 ;
40166 char * kwnames[] = {
40167 (char *) "self",(char *) "item", NULL
40168 };
40169
40170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40172 if (!SWIG_IsOK(res1)) {
40173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40174 }
40175 arg1 = reinterpret_cast< wxMenu * >(argp1);
40176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40177 if (!SWIG_IsOK(res2)) {
40178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40179 }
40180 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40181 {
40182 PyThreadState* __tstate = wxPyBeginAllowThreads();
40183 result = (bool)(arg1)->Destroy(arg2);
40184 wxPyEndAllowThreads(__tstate);
40185 if (PyErr_Occurred()) SWIG_fail;
40186 }
40187 {
40188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40189 }
40190 return resultobj;
40191 fail:
40192 return NULL;
40193 }
40194
40195
40196 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40197 PyObject *resultobj = 0;
40198 wxMenu *arg1 = (wxMenu *) 0 ;
40199 size_t result;
40200 void *argp1 = 0 ;
40201 int res1 = 0 ;
40202 PyObject *swig_obj[1] ;
40203
40204 if (!args) SWIG_fail;
40205 swig_obj[0] = args;
40206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40207 if (!SWIG_IsOK(res1)) {
40208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40209 }
40210 arg1 = reinterpret_cast< wxMenu * >(argp1);
40211 {
40212 PyThreadState* __tstate = wxPyBeginAllowThreads();
40213 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40214 wxPyEndAllowThreads(__tstate);
40215 if (PyErr_Occurred()) SWIG_fail;
40216 }
40217 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40218 return resultobj;
40219 fail:
40220 return NULL;
40221 }
40222
40223
40224 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40225 PyObject *resultobj = 0;
40226 wxMenu *arg1 = (wxMenu *) 0 ;
40227 PyObject *result = 0 ;
40228 void *argp1 = 0 ;
40229 int res1 = 0 ;
40230 PyObject *swig_obj[1] ;
40231
40232 if (!args) SWIG_fail;
40233 swig_obj[0] = args;
40234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40235 if (!SWIG_IsOK(res1)) {
40236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40237 }
40238 arg1 = reinterpret_cast< wxMenu * >(argp1);
40239 {
40240 PyThreadState* __tstate = wxPyBeginAllowThreads();
40241 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40242 wxPyEndAllowThreads(__tstate);
40243 if (PyErr_Occurred()) SWIG_fail;
40244 }
40245 resultobj = result;
40246 return resultobj;
40247 fail:
40248 return NULL;
40249 }
40250
40251
40252 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40253 PyObject *resultobj = 0;
40254 wxMenu *arg1 = (wxMenu *) 0 ;
40255 wxString *arg2 = 0 ;
40256 int result;
40257 void *argp1 = 0 ;
40258 int res1 = 0 ;
40259 bool temp2 = false ;
40260 PyObject * obj0 = 0 ;
40261 PyObject * obj1 = 0 ;
40262 char * kwnames[] = {
40263 (char *) "self",(char *) "item", NULL
40264 };
40265
40266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40268 if (!SWIG_IsOK(res1)) {
40269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40270 }
40271 arg1 = reinterpret_cast< wxMenu * >(argp1);
40272 {
40273 arg2 = wxString_in_helper(obj1);
40274 if (arg2 == NULL) SWIG_fail;
40275 temp2 = true;
40276 }
40277 {
40278 PyThreadState* __tstate = wxPyBeginAllowThreads();
40279 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40280 wxPyEndAllowThreads(__tstate);
40281 if (PyErr_Occurred()) SWIG_fail;
40282 }
40283 resultobj = SWIG_From_int(static_cast< int >(result));
40284 {
40285 if (temp2)
40286 delete arg2;
40287 }
40288 return resultobj;
40289 fail:
40290 {
40291 if (temp2)
40292 delete arg2;
40293 }
40294 return NULL;
40295 }
40296
40297
40298 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40299 PyObject *resultobj = 0;
40300 wxMenu *arg1 = (wxMenu *) 0 ;
40301 int arg2 ;
40302 wxMenuItem *result = 0 ;
40303 void *argp1 = 0 ;
40304 int res1 = 0 ;
40305 int val2 ;
40306 int ecode2 = 0 ;
40307 PyObject * obj0 = 0 ;
40308 PyObject * obj1 = 0 ;
40309 char * kwnames[] = {
40310 (char *) "self",(char *) "id", NULL
40311 };
40312
40313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40315 if (!SWIG_IsOK(res1)) {
40316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40317 }
40318 arg1 = reinterpret_cast< wxMenu * >(argp1);
40319 ecode2 = SWIG_AsVal_int(obj1, &val2);
40320 if (!SWIG_IsOK(ecode2)) {
40321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40322 }
40323 arg2 = static_cast< int >(val2);
40324 {
40325 PyThreadState* __tstate = wxPyBeginAllowThreads();
40326 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 {
40331 resultobj = wxPyMake_wxObject(result, (bool)0);
40332 }
40333 return resultobj;
40334 fail:
40335 return NULL;
40336 }
40337
40338
40339 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40340 PyObject *resultobj = 0;
40341 wxMenu *arg1 = (wxMenu *) 0 ;
40342 size_t arg2 ;
40343 wxMenuItem *result = 0 ;
40344 void *argp1 = 0 ;
40345 int res1 = 0 ;
40346 size_t val2 ;
40347 int ecode2 = 0 ;
40348 PyObject * obj0 = 0 ;
40349 PyObject * obj1 = 0 ;
40350 char * kwnames[] = {
40351 (char *) "self",(char *) "position", NULL
40352 };
40353
40354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40356 if (!SWIG_IsOK(res1)) {
40357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40358 }
40359 arg1 = reinterpret_cast< wxMenu * >(argp1);
40360 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40361 if (!SWIG_IsOK(ecode2)) {
40362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40363 }
40364 arg2 = static_cast< size_t >(val2);
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 {
40372 resultobj = wxPyMake_wxObject(result, (bool)0);
40373 }
40374 return resultobj;
40375 fail:
40376 return NULL;
40377 }
40378
40379
40380 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40381 PyObject *resultobj = 0;
40382 wxMenu *arg1 = (wxMenu *) 0 ;
40383 int arg2 ;
40384 bool arg3 ;
40385 void *argp1 = 0 ;
40386 int res1 = 0 ;
40387 int val2 ;
40388 int ecode2 = 0 ;
40389 bool val3 ;
40390 int ecode3 = 0 ;
40391 PyObject * obj0 = 0 ;
40392 PyObject * obj1 = 0 ;
40393 PyObject * obj2 = 0 ;
40394 char * kwnames[] = {
40395 (char *) "self",(char *) "id",(char *) "enable", NULL
40396 };
40397
40398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40400 if (!SWIG_IsOK(res1)) {
40401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40402 }
40403 arg1 = reinterpret_cast< wxMenu * >(argp1);
40404 ecode2 = SWIG_AsVal_int(obj1, &val2);
40405 if (!SWIG_IsOK(ecode2)) {
40406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40407 }
40408 arg2 = static_cast< int >(val2);
40409 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40410 if (!SWIG_IsOK(ecode3)) {
40411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40412 }
40413 arg3 = static_cast< bool >(val3);
40414 {
40415 PyThreadState* __tstate = wxPyBeginAllowThreads();
40416 (arg1)->Enable(arg2,arg3);
40417 wxPyEndAllowThreads(__tstate);
40418 if (PyErr_Occurred()) SWIG_fail;
40419 }
40420 resultobj = SWIG_Py_Void();
40421 return resultobj;
40422 fail:
40423 return NULL;
40424 }
40425
40426
40427 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40428 PyObject *resultobj = 0;
40429 wxMenu *arg1 = (wxMenu *) 0 ;
40430 int arg2 ;
40431 bool result;
40432 void *argp1 = 0 ;
40433 int res1 = 0 ;
40434 int val2 ;
40435 int ecode2 = 0 ;
40436 PyObject * obj0 = 0 ;
40437 PyObject * obj1 = 0 ;
40438 char * kwnames[] = {
40439 (char *) "self",(char *) "id", NULL
40440 };
40441
40442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40444 if (!SWIG_IsOK(res1)) {
40445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40446 }
40447 arg1 = reinterpret_cast< wxMenu * >(argp1);
40448 ecode2 = SWIG_AsVal_int(obj1, &val2);
40449 if (!SWIG_IsOK(ecode2)) {
40450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40451 }
40452 arg2 = static_cast< int >(val2);
40453 {
40454 PyThreadState* __tstate = wxPyBeginAllowThreads();
40455 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40456 wxPyEndAllowThreads(__tstate);
40457 if (PyErr_Occurred()) SWIG_fail;
40458 }
40459 {
40460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40461 }
40462 return resultobj;
40463 fail:
40464 return NULL;
40465 }
40466
40467
40468 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40469 PyObject *resultobj = 0;
40470 wxMenu *arg1 = (wxMenu *) 0 ;
40471 int arg2 ;
40472 bool arg3 ;
40473 void *argp1 = 0 ;
40474 int res1 = 0 ;
40475 int val2 ;
40476 int ecode2 = 0 ;
40477 bool val3 ;
40478 int ecode3 = 0 ;
40479 PyObject * obj0 = 0 ;
40480 PyObject * obj1 = 0 ;
40481 PyObject * obj2 = 0 ;
40482 char * kwnames[] = {
40483 (char *) "self",(char *) "id",(char *) "check", NULL
40484 };
40485
40486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40488 if (!SWIG_IsOK(res1)) {
40489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40490 }
40491 arg1 = reinterpret_cast< wxMenu * >(argp1);
40492 ecode2 = SWIG_AsVal_int(obj1, &val2);
40493 if (!SWIG_IsOK(ecode2)) {
40494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40495 }
40496 arg2 = static_cast< int >(val2);
40497 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40498 if (!SWIG_IsOK(ecode3)) {
40499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40500 }
40501 arg3 = static_cast< bool >(val3);
40502 {
40503 PyThreadState* __tstate = wxPyBeginAllowThreads();
40504 (arg1)->Check(arg2,arg3);
40505 wxPyEndAllowThreads(__tstate);
40506 if (PyErr_Occurred()) SWIG_fail;
40507 }
40508 resultobj = SWIG_Py_Void();
40509 return resultobj;
40510 fail:
40511 return NULL;
40512 }
40513
40514
40515 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40516 PyObject *resultobj = 0;
40517 wxMenu *arg1 = (wxMenu *) 0 ;
40518 int arg2 ;
40519 bool result;
40520 void *argp1 = 0 ;
40521 int res1 = 0 ;
40522 int val2 ;
40523 int ecode2 = 0 ;
40524 PyObject * obj0 = 0 ;
40525 PyObject * obj1 = 0 ;
40526 char * kwnames[] = {
40527 (char *) "self",(char *) "id", NULL
40528 };
40529
40530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40532 if (!SWIG_IsOK(res1)) {
40533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40534 }
40535 arg1 = reinterpret_cast< wxMenu * >(argp1);
40536 ecode2 = SWIG_AsVal_int(obj1, &val2);
40537 if (!SWIG_IsOK(ecode2)) {
40538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40539 }
40540 arg2 = static_cast< int >(val2);
40541 {
40542 PyThreadState* __tstate = wxPyBeginAllowThreads();
40543 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40544 wxPyEndAllowThreads(__tstate);
40545 if (PyErr_Occurred()) SWIG_fail;
40546 }
40547 {
40548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40549 }
40550 return resultobj;
40551 fail:
40552 return NULL;
40553 }
40554
40555
40556 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40557 PyObject *resultobj = 0;
40558 wxMenu *arg1 = (wxMenu *) 0 ;
40559 int arg2 ;
40560 wxString *arg3 = 0 ;
40561 void *argp1 = 0 ;
40562 int res1 = 0 ;
40563 int val2 ;
40564 int ecode2 = 0 ;
40565 bool temp3 = false ;
40566 PyObject * obj0 = 0 ;
40567 PyObject * obj1 = 0 ;
40568 PyObject * obj2 = 0 ;
40569 char * kwnames[] = {
40570 (char *) "self",(char *) "id",(char *) "label", NULL
40571 };
40572
40573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40575 if (!SWIG_IsOK(res1)) {
40576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40577 }
40578 arg1 = reinterpret_cast< wxMenu * >(argp1);
40579 ecode2 = SWIG_AsVal_int(obj1, &val2);
40580 if (!SWIG_IsOK(ecode2)) {
40581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40582 }
40583 arg2 = static_cast< int >(val2);
40584 {
40585 arg3 = wxString_in_helper(obj2);
40586 if (arg3 == NULL) SWIG_fail;
40587 temp3 = true;
40588 }
40589 {
40590 PyThreadState* __tstate = wxPyBeginAllowThreads();
40591 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40592 wxPyEndAllowThreads(__tstate);
40593 if (PyErr_Occurred()) SWIG_fail;
40594 }
40595 resultobj = SWIG_Py_Void();
40596 {
40597 if (temp3)
40598 delete arg3;
40599 }
40600 return resultobj;
40601 fail:
40602 {
40603 if (temp3)
40604 delete arg3;
40605 }
40606 return NULL;
40607 }
40608
40609
40610 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40611 PyObject *resultobj = 0;
40612 wxMenu *arg1 = (wxMenu *) 0 ;
40613 int arg2 ;
40614 wxString result;
40615 void *argp1 = 0 ;
40616 int res1 = 0 ;
40617 int val2 ;
40618 int ecode2 = 0 ;
40619 PyObject * obj0 = 0 ;
40620 PyObject * obj1 = 0 ;
40621 char * kwnames[] = {
40622 (char *) "self",(char *) "id", NULL
40623 };
40624
40625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40627 if (!SWIG_IsOK(res1)) {
40628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40629 }
40630 arg1 = reinterpret_cast< wxMenu * >(argp1);
40631 ecode2 = SWIG_AsVal_int(obj1, &val2);
40632 if (!SWIG_IsOK(ecode2)) {
40633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40634 }
40635 arg2 = static_cast< int >(val2);
40636 {
40637 PyThreadState* __tstate = wxPyBeginAllowThreads();
40638 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40639 wxPyEndAllowThreads(__tstate);
40640 if (PyErr_Occurred()) SWIG_fail;
40641 }
40642 {
40643 #if wxUSE_UNICODE
40644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40645 #else
40646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40647 #endif
40648 }
40649 return resultobj;
40650 fail:
40651 return NULL;
40652 }
40653
40654
40655 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40656 PyObject *resultobj = 0;
40657 wxMenu *arg1 = (wxMenu *) 0 ;
40658 int arg2 ;
40659 wxString *arg3 = 0 ;
40660 void *argp1 = 0 ;
40661 int res1 = 0 ;
40662 int val2 ;
40663 int ecode2 = 0 ;
40664 bool temp3 = false ;
40665 PyObject * obj0 = 0 ;
40666 PyObject * obj1 = 0 ;
40667 PyObject * obj2 = 0 ;
40668 char * kwnames[] = {
40669 (char *) "self",(char *) "id",(char *) "helpString", NULL
40670 };
40671
40672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40674 if (!SWIG_IsOK(res1)) {
40675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40676 }
40677 arg1 = reinterpret_cast< wxMenu * >(argp1);
40678 ecode2 = SWIG_AsVal_int(obj1, &val2);
40679 if (!SWIG_IsOK(ecode2)) {
40680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40681 }
40682 arg2 = static_cast< int >(val2);
40683 {
40684 arg3 = wxString_in_helper(obj2);
40685 if (arg3 == NULL) SWIG_fail;
40686 temp3 = true;
40687 }
40688 {
40689 PyThreadState* __tstate = wxPyBeginAllowThreads();
40690 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40691 wxPyEndAllowThreads(__tstate);
40692 if (PyErr_Occurred()) SWIG_fail;
40693 }
40694 resultobj = SWIG_Py_Void();
40695 {
40696 if (temp3)
40697 delete arg3;
40698 }
40699 return resultobj;
40700 fail:
40701 {
40702 if (temp3)
40703 delete arg3;
40704 }
40705 return NULL;
40706 }
40707
40708
40709 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40710 PyObject *resultobj = 0;
40711 wxMenu *arg1 = (wxMenu *) 0 ;
40712 int arg2 ;
40713 wxString result;
40714 void *argp1 = 0 ;
40715 int res1 = 0 ;
40716 int val2 ;
40717 int ecode2 = 0 ;
40718 PyObject * obj0 = 0 ;
40719 PyObject * obj1 = 0 ;
40720 char * kwnames[] = {
40721 (char *) "self",(char *) "id", NULL
40722 };
40723
40724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40726 if (!SWIG_IsOK(res1)) {
40727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40728 }
40729 arg1 = reinterpret_cast< wxMenu * >(argp1);
40730 ecode2 = SWIG_AsVal_int(obj1, &val2);
40731 if (!SWIG_IsOK(ecode2)) {
40732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40733 }
40734 arg2 = static_cast< int >(val2);
40735 {
40736 PyThreadState* __tstate = wxPyBeginAllowThreads();
40737 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40738 wxPyEndAllowThreads(__tstate);
40739 if (PyErr_Occurred()) SWIG_fail;
40740 }
40741 {
40742 #if wxUSE_UNICODE
40743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40744 #else
40745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40746 #endif
40747 }
40748 return resultobj;
40749 fail:
40750 return NULL;
40751 }
40752
40753
40754 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40755 PyObject *resultobj = 0;
40756 wxMenu *arg1 = (wxMenu *) 0 ;
40757 wxString *arg2 = 0 ;
40758 void *argp1 = 0 ;
40759 int res1 = 0 ;
40760 bool temp2 = false ;
40761 PyObject * obj0 = 0 ;
40762 PyObject * obj1 = 0 ;
40763 char * kwnames[] = {
40764 (char *) "self",(char *) "title", NULL
40765 };
40766
40767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40769 if (!SWIG_IsOK(res1)) {
40770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40771 }
40772 arg1 = reinterpret_cast< wxMenu * >(argp1);
40773 {
40774 arg2 = wxString_in_helper(obj1);
40775 if (arg2 == NULL) SWIG_fail;
40776 temp2 = true;
40777 }
40778 {
40779 PyThreadState* __tstate = wxPyBeginAllowThreads();
40780 (arg1)->SetTitle((wxString const &)*arg2);
40781 wxPyEndAllowThreads(__tstate);
40782 if (PyErr_Occurred()) SWIG_fail;
40783 }
40784 resultobj = SWIG_Py_Void();
40785 {
40786 if (temp2)
40787 delete arg2;
40788 }
40789 return resultobj;
40790 fail:
40791 {
40792 if (temp2)
40793 delete arg2;
40794 }
40795 return NULL;
40796 }
40797
40798
40799 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40800 PyObject *resultobj = 0;
40801 wxMenu *arg1 = (wxMenu *) 0 ;
40802 wxString result;
40803 void *argp1 = 0 ;
40804 int res1 = 0 ;
40805 PyObject *swig_obj[1] ;
40806
40807 if (!args) SWIG_fail;
40808 swig_obj[0] = args;
40809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40810 if (!SWIG_IsOK(res1)) {
40811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40812 }
40813 arg1 = reinterpret_cast< wxMenu * >(argp1);
40814 {
40815 PyThreadState* __tstate = wxPyBeginAllowThreads();
40816 result = ((wxMenu const *)arg1)->GetTitle();
40817 wxPyEndAllowThreads(__tstate);
40818 if (PyErr_Occurred()) SWIG_fail;
40819 }
40820 {
40821 #if wxUSE_UNICODE
40822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40823 #else
40824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40825 #endif
40826 }
40827 return resultobj;
40828 fail:
40829 return NULL;
40830 }
40831
40832
40833 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40834 PyObject *resultobj = 0;
40835 wxMenu *arg1 = (wxMenu *) 0 ;
40836 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40837 void *argp1 = 0 ;
40838 int res1 = 0 ;
40839 void *argp2 = 0 ;
40840 int res2 = 0 ;
40841 PyObject * obj0 = 0 ;
40842 PyObject * obj1 = 0 ;
40843 char * kwnames[] = {
40844 (char *) "self",(char *) "handler", NULL
40845 };
40846
40847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40849 if (!SWIG_IsOK(res1)) {
40850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40851 }
40852 arg1 = reinterpret_cast< wxMenu * >(argp1);
40853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40854 if (!SWIG_IsOK(res2)) {
40855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40856 }
40857 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40858 {
40859 PyThreadState* __tstate = wxPyBeginAllowThreads();
40860 (arg1)->SetEventHandler(arg2);
40861 wxPyEndAllowThreads(__tstate);
40862 if (PyErr_Occurred()) SWIG_fail;
40863 }
40864 resultobj = SWIG_Py_Void();
40865 return resultobj;
40866 fail:
40867 return NULL;
40868 }
40869
40870
40871 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40872 PyObject *resultobj = 0;
40873 wxMenu *arg1 = (wxMenu *) 0 ;
40874 wxEvtHandler *result = 0 ;
40875 void *argp1 = 0 ;
40876 int res1 = 0 ;
40877 PyObject *swig_obj[1] ;
40878
40879 if (!args) SWIG_fail;
40880 swig_obj[0] = args;
40881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40882 if (!SWIG_IsOK(res1)) {
40883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40884 }
40885 arg1 = reinterpret_cast< wxMenu * >(argp1);
40886 {
40887 PyThreadState* __tstate = wxPyBeginAllowThreads();
40888 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40889 wxPyEndAllowThreads(__tstate);
40890 if (PyErr_Occurred()) SWIG_fail;
40891 }
40892 {
40893 resultobj = wxPyMake_wxObject(result, 0);
40894 }
40895 return resultobj;
40896 fail:
40897 return NULL;
40898 }
40899
40900
40901 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40902 PyObject *resultobj = 0;
40903 wxMenu *arg1 = (wxMenu *) 0 ;
40904 wxWindow *arg2 = (wxWindow *) 0 ;
40905 void *argp1 = 0 ;
40906 int res1 = 0 ;
40907 void *argp2 = 0 ;
40908 int res2 = 0 ;
40909 PyObject * obj0 = 0 ;
40910 PyObject * obj1 = 0 ;
40911 char * kwnames[] = {
40912 (char *) "self",(char *) "win", NULL
40913 };
40914
40915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40917 if (!SWIG_IsOK(res1)) {
40918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40919 }
40920 arg1 = reinterpret_cast< wxMenu * >(argp1);
40921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40922 if (!SWIG_IsOK(res2)) {
40923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40924 }
40925 arg2 = reinterpret_cast< wxWindow * >(argp2);
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 (arg1)->SetInvokingWindow(arg2);
40929 wxPyEndAllowThreads(__tstate);
40930 if (PyErr_Occurred()) SWIG_fail;
40931 }
40932 resultobj = SWIG_Py_Void();
40933 return resultobj;
40934 fail:
40935 return NULL;
40936 }
40937
40938
40939 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40940 PyObject *resultobj = 0;
40941 wxMenu *arg1 = (wxMenu *) 0 ;
40942 wxWindow *result = 0 ;
40943 void *argp1 = 0 ;
40944 int res1 = 0 ;
40945 PyObject *swig_obj[1] ;
40946
40947 if (!args) SWIG_fail;
40948 swig_obj[0] = args;
40949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40950 if (!SWIG_IsOK(res1)) {
40951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40952 }
40953 arg1 = reinterpret_cast< wxMenu * >(argp1);
40954 {
40955 PyThreadState* __tstate = wxPyBeginAllowThreads();
40956 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40957 wxPyEndAllowThreads(__tstate);
40958 if (PyErr_Occurred()) SWIG_fail;
40959 }
40960 {
40961 resultobj = wxPyMake_wxObject(result, 0);
40962 }
40963 return resultobj;
40964 fail:
40965 return NULL;
40966 }
40967
40968
40969 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40970 PyObject *resultobj = 0;
40971 wxMenu *arg1 = (wxMenu *) 0 ;
40972 long result;
40973 void *argp1 = 0 ;
40974 int res1 = 0 ;
40975 PyObject *swig_obj[1] ;
40976
40977 if (!args) SWIG_fail;
40978 swig_obj[0] = args;
40979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40980 if (!SWIG_IsOK(res1)) {
40981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40982 }
40983 arg1 = reinterpret_cast< wxMenu * >(argp1);
40984 {
40985 PyThreadState* __tstate = wxPyBeginAllowThreads();
40986 result = (long)((wxMenu const *)arg1)->GetStyle();
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 resultobj = SWIG_From_long(static_cast< long >(result));
40991 return resultobj;
40992 fail:
40993 return NULL;
40994 }
40995
40996
40997 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40998 PyObject *resultobj = 0;
40999 wxMenu *arg1 = (wxMenu *) 0 ;
41000 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41001 void *argp1 = 0 ;
41002 int res1 = 0 ;
41003 void *argp2 = 0 ;
41004 int res2 = 0 ;
41005 PyObject * obj0 = 0 ;
41006 PyObject * obj1 = 0 ;
41007 char * kwnames[] = {
41008 (char *) "self",(char *) "source", NULL
41009 };
41010
41011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41013 if (!SWIG_IsOK(res1)) {
41014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41015 }
41016 arg1 = reinterpret_cast< wxMenu * >(argp1);
41017 if (obj1) {
41018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41019 if (!SWIG_IsOK(res2)) {
41020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41021 }
41022 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41023 }
41024 {
41025 PyThreadState* __tstate = wxPyBeginAllowThreads();
41026 (arg1)->UpdateUI(arg2);
41027 wxPyEndAllowThreads(__tstate);
41028 if (PyErr_Occurred()) SWIG_fail;
41029 }
41030 resultobj = SWIG_Py_Void();
41031 return resultobj;
41032 fail:
41033 return NULL;
41034 }
41035
41036
41037 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41038 PyObject *resultobj = 0;
41039 wxMenu *arg1 = (wxMenu *) 0 ;
41040 wxMenuBar *result = 0 ;
41041 void *argp1 = 0 ;
41042 int res1 = 0 ;
41043 PyObject *swig_obj[1] ;
41044
41045 if (!args) SWIG_fail;
41046 swig_obj[0] = args;
41047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41048 if (!SWIG_IsOK(res1)) {
41049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41050 }
41051 arg1 = reinterpret_cast< wxMenu * >(argp1);
41052 {
41053 PyThreadState* __tstate = wxPyBeginAllowThreads();
41054 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41055 wxPyEndAllowThreads(__tstate);
41056 if (PyErr_Occurred()) SWIG_fail;
41057 }
41058 {
41059 resultobj = wxPyMake_wxObject(result, (bool)0);
41060 }
41061 return resultobj;
41062 fail:
41063 return NULL;
41064 }
41065
41066
41067 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41068 PyObject *resultobj = 0;
41069 wxMenu *arg1 = (wxMenu *) 0 ;
41070 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41071 void *argp1 = 0 ;
41072 int res1 = 0 ;
41073 void *argp2 = 0 ;
41074 int res2 = 0 ;
41075 PyObject * obj0 = 0 ;
41076 PyObject * obj1 = 0 ;
41077 char * kwnames[] = {
41078 (char *) "self",(char *) "menubar", NULL
41079 };
41080
41081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41083 if (!SWIG_IsOK(res1)) {
41084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41085 }
41086 arg1 = reinterpret_cast< wxMenu * >(argp1);
41087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41088 if (!SWIG_IsOK(res2)) {
41089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41090 }
41091 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41092 {
41093 PyThreadState* __tstate = wxPyBeginAllowThreads();
41094 (arg1)->Attach(arg2);
41095 wxPyEndAllowThreads(__tstate);
41096 if (PyErr_Occurred()) SWIG_fail;
41097 }
41098 resultobj = SWIG_Py_Void();
41099 return resultobj;
41100 fail:
41101 return NULL;
41102 }
41103
41104
41105 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41106 PyObject *resultobj = 0;
41107 wxMenu *arg1 = (wxMenu *) 0 ;
41108 void *argp1 = 0 ;
41109 int res1 = 0 ;
41110 PyObject *swig_obj[1] ;
41111
41112 if (!args) SWIG_fail;
41113 swig_obj[0] = args;
41114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41115 if (!SWIG_IsOK(res1)) {
41116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41117 }
41118 arg1 = reinterpret_cast< wxMenu * >(argp1);
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 (arg1)->Detach();
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 resultobj = SWIG_Py_Void();
41126 return resultobj;
41127 fail:
41128 return NULL;
41129 }
41130
41131
41132 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41133 PyObject *resultobj = 0;
41134 wxMenu *arg1 = (wxMenu *) 0 ;
41135 bool result;
41136 void *argp1 = 0 ;
41137 int res1 = 0 ;
41138 PyObject *swig_obj[1] ;
41139
41140 if (!args) SWIG_fail;
41141 swig_obj[0] = args;
41142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41143 if (!SWIG_IsOK(res1)) {
41144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41145 }
41146 arg1 = reinterpret_cast< wxMenu * >(argp1);
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 result = (bool)((wxMenu const *)arg1)->IsAttached();
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 {
41154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41155 }
41156 return resultobj;
41157 fail:
41158 return NULL;
41159 }
41160
41161
41162 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41163 PyObject *resultobj = 0;
41164 wxMenu *arg1 = (wxMenu *) 0 ;
41165 wxMenu *arg2 = (wxMenu *) 0 ;
41166 void *argp1 = 0 ;
41167 int res1 = 0 ;
41168 void *argp2 = 0 ;
41169 int res2 = 0 ;
41170 PyObject * obj0 = 0 ;
41171 PyObject * obj1 = 0 ;
41172 char * kwnames[] = {
41173 (char *) "self",(char *) "parent", NULL
41174 };
41175
41176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41178 if (!SWIG_IsOK(res1)) {
41179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41180 }
41181 arg1 = reinterpret_cast< wxMenu * >(argp1);
41182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41183 if (!SWIG_IsOK(res2)) {
41184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41185 }
41186 arg2 = reinterpret_cast< wxMenu * >(argp2);
41187 {
41188 PyThreadState* __tstate = wxPyBeginAllowThreads();
41189 (arg1)->SetParent(arg2);
41190 wxPyEndAllowThreads(__tstate);
41191 if (PyErr_Occurred()) SWIG_fail;
41192 }
41193 resultobj = SWIG_Py_Void();
41194 return resultobj;
41195 fail:
41196 return NULL;
41197 }
41198
41199
41200 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41201 PyObject *resultobj = 0;
41202 wxMenu *arg1 = (wxMenu *) 0 ;
41203 wxMenu *result = 0 ;
41204 void *argp1 = 0 ;
41205 int res1 = 0 ;
41206 PyObject *swig_obj[1] ;
41207
41208 if (!args) SWIG_fail;
41209 swig_obj[0] = args;
41210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41211 if (!SWIG_IsOK(res1)) {
41212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41213 }
41214 arg1 = reinterpret_cast< wxMenu * >(argp1);
41215 {
41216 PyThreadState* __tstate = wxPyBeginAllowThreads();
41217 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41218 wxPyEndAllowThreads(__tstate);
41219 if (PyErr_Occurred()) SWIG_fail;
41220 }
41221 {
41222 resultobj = wxPyMake_wxObject(result, 0);
41223 }
41224 return resultobj;
41225 fail:
41226 return NULL;
41227 }
41228
41229
41230 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41231 PyObject *obj;
41232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41233 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41234 return SWIG_Py_Void();
41235 }
41236
41237 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41238 return SWIG_Python_InitShadowInstance(args);
41239 }
41240
41241 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41242 PyObject *resultobj = 0;
41243 long arg1 = (long) 0 ;
41244 wxMenuBar *result = 0 ;
41245 long val1 ;
41246 int ecode1 = 0 ;
41247 PyObject * obj0 = 0 ;
41248 char * kwnames[] = {
41249 (char *) "style", NULL
41250 };
41251
41252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41253 if (obj0) {
41254 ecode1 = SWIG_AsVal_long(obj0, &val1);
41255 if (!SWIG_IsOK(ecode1)) {
41256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41257 }
41258 arg1 = static_cast< long >(val1);
41259 }
41260 {
41261 if (!wxPyCheckForApp()) SWIG_fail;
41262 PyThreadState* __tstate = wxPyBeginAllowThreads();
41263 result = (wxMenuBar *)new wxMenuBar(arg1);
41264 wxPyEndAllowThreads(__tstate);
41265 if (PyErr_Occurred()) SWIG_fail;
41266 }
41267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41268 return resultobj;
41269 fail:
41270 return NULL;
41271 }
41272
41273
41274 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41275 PyObject *resultobj = 0;
41276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41277 wxMenu *arg2 = (wxMenu *) 0 ;
41278 wxString *arg3 = 0 ;
41279 bool result;
41280 void *argp1 = 0 ;
41281 int res1 = 0 ;
41282 void *argp2 = 0 ;
41283 int res2 = 0 ;
41284 bool temp3 = false ;
41285 PyObject * obj0 = 0 ;
41286 PyObject * obj1 = 0 ;
41287 PyObject * obj2 = 0 ;
41288 char * kwnames[] = {
41289 (char *) "self",(char *) "menu",(char *) "title", NULL
41290 };
41291
41292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41294 if (!SWIG_IsOK(res1)) {
41295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41296 }
41297 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41299 if (!SWIG_IsOK(res2)) {
41300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41301 }
41302 arg2 = reinterpret_cast< wxMenu * >(argp2);
41303 {
41304 arg3 = wxString_in_helper(obj2);
41305 if (arg3 == NULL) SWIG_fail;
41306 temp3 = true;
41307 }
41308 {
41309 PyThreadState* __tstate = wxPyBeginAllowThreads();
41310 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41311 wxPyEndAllowThreads(__tstate);
41312 if (PyErr_Occurred()) SWIG_fail;
41313 }
41314 {
41315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41316 }
41317 {
41318 if (temp3)
41319 delete arg3;
41320 }
41321 return resultobj;
41322 fail:
41323 {
41324 if (temp3)
41325 delete arg3;
41326 }
41327 return NULL;
41328 }
41329
41330
41331 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41332 PyObject *resultobj = 0;
41333 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41334 size_t arg2 ;
41335 wxMenu *arg3 = (wxMenu *) 0 ;
41336 wxString *arg4 = 0 ;
41337 bool result;
41338 void *argp1 = 0 ;
41339 int res1 = 0 ;
41340 size_t val2 ;
41341 int ecode2 = 0 ;
41342 void *argp3 = 0 ;
41343 int res3 = 0 ;
41344 bool temp4 = false ;
41345 PyObject * obj0 = 0 ;
41346 PyObject * obj1 = 0 ;
41347 PyObject * obj2 = 0 ;
41348 PyObject * obj3 = 0 ;
41349 char * kwnames[] = {
41350 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41351 };
41352
41353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41355 if (!SWIG_IsOK(res1)) {
41356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41357 }
41358 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41359 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41360 if (!SWIG_IsOK(ecode2)) {
41361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41362 }
41363 arg2 = static_cast< size_t >(val2);
41364 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41365 if (!SWIG_IsOK(res3)) {
41366 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41367 }
41368 arg3 = reinterpret_cast< wxMenu * >(argp3);
41369 {
41370 arg4 = wxString_in_helper(obj3);
41371 if (arg4 == NULL) SWIG_fail;
41372 temp4 = true;
41373 }
41374 {
41375 PyThreadState* __tstate = wxPyBeginAllowThreads();
41376 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41377 wxPyEndAllowThreads(__tstate);
41378 if (PyErr_Occurred()) SWIG_fail;
41379 }
41380 {
41381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41382 }
41383 {
41384 if (temp4)
41385 delete arg4;
41386 }
41387 return resultobj;
41388 fail:
41389 {
41390 if (temp4)
41391 delete arg4;
41392 }
41393 return NULL;
41394 }
41395
41396
41397 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41398 PyObject *resultobj = 0;
41399 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41400 size_t result;
41401 void *argp1 = 0 ;
41402 int res1 = 0 ;
41403 PyObject *swig_obj[1] ;
41404
41405 if (!args) SWIG_fail;
41406 swig_obj[0] = args;
41407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41408 if (!SWIG_IsOK(res1)) {
41409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41410 }
41411 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41412 {
41413 PyThreadState* __tstate = wxPyBeginAllowThreads();
41414 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41415 wxPyEndAllowThreads(__tstate);
41416 if (PyErr_Occurred()) SWIG_fail;
41417 }
41418 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41419 return resultobj;
41420 fail:
41421 return NULL;
41422 }
41423
41424
41425 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41426 PyObject *resultobj = 0;
41427 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41428 size_t arg2 ;
41429 wxMenu *result = 0 ;
41430 void *argp1 = 0 ;
41431 int res1 = 0 ;
41432 size_t val2 ;
41433 int ecode2 = 0 ;
41434 PyObject * obj0 = 0 ;
41435 PyObject * obj1 = 0 ;
41436 char * kwnames[] = {
41437 (char *) "self",(char *) "pos", NULL
41438 };
41439
41440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41442 if (!SWIG_IsOK(res1)) {
41443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41444 }
41445 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41446 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41447 if (!SWIG_IsOK(ecode2)) {
41448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41449 }
41450 arg2 = static_cast< size_t >(val2);
41451 {
41452 PyThreadState* __tstate = wxPyBeginAllowThreads();
41453 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41454 wxPyEndAllowThreads(__tstate);
41455 if (PyErr_Occurred()) SWIG_fail;
41456 }
41457 {
41458 resultobj = wxPyMake_wxObject(result, 0);
41459 }
41460 return resultobj;
41461 fail:
41462 return NULL;
41463 }
41464
41465
41466 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41467 PyObject *resultobj = 0;
41468 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41469 size_t arg2 ;
41470 wxMenu *arg3 = (wxMenu *) 0 ;
41471 wxString *arg4 = 0 ;
41472 wxMenu *result = 0 ;
41473 void *argp1 = 0 ;
41474 int res1 = 0 ;
41475 size_t val2 ;
41476 int ecode2 = 0 ;
41477 void *argp3 = 0 ;
41478 int res3 = 0 ;
41479 bool temp4 = false ;
41480 PyObject * obj0 = 0 ;
41481 PyObject * obj1 = 0 ;
41482 PyObject * obj2 = 0 ;
41483 PyObject * obj3 = 0 ;
41484 char * kwnames[] = {
41485 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41486 };
41487
41488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41490 if (!SWIG_IsOK(res1)) {
41491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41492 }
41493 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41494 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41495 if (!SWIG_IsOK(ecode2)) {
41496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41497 }
41498 arg2 = static_cast< size_t >(val2);
41499 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41500 if (!SWIG_IsOK(res3)) {
41501 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41502 }
41503 arg3 = reinterpret_cast< wxMenu * >(argp3);
41504 {
41505 arg4 = wxString_in_helper(obj3);
41506 if (arg4 == NULL) SWIG_fail;
41507 temp4 = true;
41508 }
41509 {
41510 PyThreadState* __tstate = wxPyBeginAllowThreads();
41511 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41512 wxPyEndAllowThreads(__tstate);
41513 if (PyErr_Occurred()) SWIG_fail;
41514 }
41515 {
41516 resultobj = wxPyMake_wxObject(result, 0);
41517 }
41518 {
41519 if (temp4)
41520 delete arg4;
41521 }
41522 return resultobj;
41523 fail:
41524 {
41525 if (temp4)
41526 delete arg4;
41527 }
41528 return NULL;
41529 }
41530
41531
41532 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41533 PyObject *resultobj = 0;
41534 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41535 size_t arg2 ;
41536 wxMenu *result = 0 ;
41537 void *argp1 = 0 ;
41538 int res1 = 0 ;
41539 size_t val2 ;
41540 int ecode2 = 0 ;
41541 PyObject * obj0 = 0 ;
41542 PyObject * obj1 = 0 ;
41543 char * kwnames[] = {
41544 (char *) "self",(char *) "pos", NULL
41545 };
41546
41547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41549 if (!SWIG_IsOK(res1)) {
41550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41551 }
41552 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41553 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41554 if (!SWIG_IsOK(ecode2)) {
41555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41556 }
41557 arg2 = static_cast< size_t >(val2);
41558 {
41559 PyThreadState* __tstate = wxPyBeginAllowThreads();
41560 result = (wxMenu *)(arg1)->Remove(arg2);
41561 wxPyEndAllowThreads(__tstate);
41562 if (PyErr_Occurred()) SWIG_fail;
41563 }
41564 {
41565 resultobj = wxPyMake_wxObject(result, 0);
41566 }
41567 return resultobj;
41568 fail:
41569 return NULL;
41570 }
41571
41572
41573 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41574 PyObject *resultobj = 0;
41575 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41576 size_t arg2 ;
41577 bool arg3 ;
41578 void *argp1 = 0 ;
41579 int res1 = 0 ;
41580 size_t val2 ;
41581 int ecode2 = 0 ;
41582 bool val3 ;
41583 int ecode3 = 0 ;
41584 PyObject * obj0 = 0 ;
41585 PyObject * obj1 = 0 ;
41586 PyObject * obj2 = 0 ;
41587 char * kwnames[] = {
41588 (char *) "self",(char *) "pos",(char *) "enable", NULL
41589 };
41590
41591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41593 if (!SWIG_IsOK(res1)) {
41594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41595 }
41596 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41597 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41598 if (!SWIG_IsOK(ecode2)) {
41599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41600 }
41601 arg2 = static_cast< size_t >(val2);
41602 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41603 if (!SWIG_IsOK(ecode3)) {
41604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41605 }
41606 arg3 = static_cast< bool >(val3);
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 (arg1)->EnableTop(arg2,arg3);
41610 wxPyEndAllowThreads(__tstate);
41611 if (PyErr_Occurred()) SWIG_fail;
41612 }
41613 resultobj = SWIG_Py_Void();
41614 return resultobj;
41615 fail:
41616 return NULL;
41617 }
41618
41619
41620 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41621 PyObject *resultobj = 0;
41622 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41623 size_t arg2 ;
41624 bool result;
41625 void *argp1 = 0 ;
41626 int res1 = 0 ;
41627 size_t val2 ;
41628 int ecode2 = 0 ;
41629 PyObject * obj0 = 0 ;
41630 PyObject * obj1 = 0 ;
41631 char * kwnames[] = {
41632 (char *) "self",(char *) "pos", NULL
41633 };
41634
41635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41639 }
41640 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41641 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41642 if (!SWIG_IsOK(ecode2)) {
41643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41644 }
41645 arg2 = static_cast< size_t >(val2);
41646 {
41647 PyThreadState* __tstate = wxPyBeginAllowThreads();
41648 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41649 wxPyEndAllowThreads(__tstate);
41650 if (PyErr_Occurred()) SWIG_fail;
41651 }
41652 {
41653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41654 }
41655 return resultobj;
41656 fail:
41657 return NULL;
41658 }
41659
41660
41661 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41662 PyObject *resultobj = 0;
41663 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41664 size_t arg2 ;
41665 wxString *arg3 = 0 ;
41666 void *argp1 = 0 ;
41667 int res1 = 0 ;
41668 size_t val2 ;
41669 int ecode2 = 0 ;
41670 bool temp3 = false ;
41671 PyObject * obj0 = 0 ;
41672 PyObject * obj1 = 0 ;
41673 PyObject * obj2 = 0 ;
41674 char * kwnames[] = {
41675 (char *) "self",(char *) "pos",(char *) "label", NULL
41676 };
41677
41678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41680 if (!SWIG_IsOK(res1)) {
41681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41682 }
41683 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41685 if (!SWIG_IsOK(ecode2)) {
41686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41687 }
41688 arg2 = static_cast< size_t >(val2);
41689 {
41690 arg3 = wxString_in_helper(obj2);
41691 if (arg3 == NULL) SWIG_fail;
41692 temp3 = true;
41693 }
41694 {
41695 PyThreadState* __tstate = wxPyBeginAllowThreads();
41696 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41697 wxPyEndAllowThreads(__tstate);
41698 if (PyErr_Occurred()) SWIG_fail;
41699 }
41700 resultobj = SWIG_Py_Void();
41701 {
41702 if (temp3)
41703 delete arg3;
41704 }
41705 return resultobj;
41706 fail:
41707 {
41708 if (temp3)
41709 delete arg3;
41710 }
41711 return NULL;
41712 }
41713
41714
41715 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41716 PyObject *resultobj = 0;
41717 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41718 size_t arg2 ;
41719 wxString result;
41720 void *argp1 = 0 ;
41721 int res1 = 0 ;
41722 size_t val2 ;
41723 int ecode2 = 0 ;
41724 PyObject * obj0 = 0 ;
41725 PyObject * obj1 = 0 ;
41726 char * kwnames[] = {
41727 (char *) "self",(char *) "pos", NULL
41728 };
41729
41730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41732 if (!SWIG_IsOK(res1)) {
41733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41734 }
41735 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41736 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41737 if (!SWIG_IsOK(ecode2)) {
41738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41739 }
41740 arg2 = static_cast< size_t >(val2);
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 {
41748 #if wxUSE_UNICODE
41749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41750 #else
41751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41752 #endif
41753 }
41754 return resultobj;
41755 fail:
41756 return NULL;
41757 }
41758
41759
41760 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41761 PyObject *resultobj = 0;
41762 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41763 wxString *arg2 = 0 ;
41764 wxString *arg3 = 0 ;
41765 int result;
41766 void *argp1 = 0 ;
41767 int res1 = 0 ;
41768 bool temp2 = false ;
41769 bool temp3 = false ;
41770 PyObject * obj0 = 0 ;
41771 PyObject * obj1 = 0 ;
41772 PyObject * obj2 = 0 ;
41773 char * kwnames[] = {
41774 (char *) "self",(char *) "menu",(char *) "item", NULL
41775 };
41776
41777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41779 if (!SWIG_IsOK(res1)) {
41780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41781 }
41782 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41783 {
41784 arg2 = wxString_in_helper(obj1);
41785 if (arg2 == NULL) SWIG_fail;
41786 temp2 = true;
41787 }
41788 {
41789 arg3 = wxString_in_helper(obj2);
41790 if (arg3 == NULL) SWIG_fail;
41791 temp3 = true;
41792 }
41793 {
41794 PyThreadState* __tstate = wxPyBeginAllowThreads();
41795 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41796 wxPyEndAllowThreads(__tstate);
41797 if (PyErr_Occurred()) SWIG_fail;
41798 }
41799 resultobj = SWIG_From_int(static_cast< int >(result));
41800 {
41801 if (temp2)
41802 delete arg2;
41803 }
41804 {
41805 if (temp3)
41806 delete arg3;
41807 }
41808 return resultobj;
41809 fail:
41810 {
41811 if (temp2)
41812 delete arg2;
41813 }
41814 {
41815 if (temp3)
41816 delete arg3;
41817 }
41818 return NULL;
41819 }
41820
41821
41822 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41823 PyObject *resultobj = 0;
41824 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41825 int arg2 ;
41826 wxMenuItem *result = 0 ;
41827 void *argp1 = 0 ;
41828 int res1 = 0 ;
41829 int val2 ;
41830 int ecode2 = 0 ;
41831 PyObject * obj0 = 0 ;
41832 PyObject * obj1 = 0 ;
41833 char * kwnames[] = {
41834 (char *) "self",(char *) "id", NULL
41835 };
41836
41837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41839 if (!SWIG_IsOK(res1)) {
41840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41841 }
41842 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41843 ecode2 = SWIG_AsVal_int(obj1, &val2);
41844 if (!SWIG_IsOK(ecode2)) {
41845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41846 }
41847 arg2 = static_cast< int >(val2);
41848 {
41849 PyThreadState* __tstate = wxPyBeginAllowThreads();
41850 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41851 wxPyEndAllowThreads(__tstate);
41852 if (PyErr_Occurred()) SWIG_fail;
41853 }
41854 {
41855 resultobj = wxPyMake_wxObject(result, (bool)0);
41856 }
41857 return resultobj;
41858 fail:
41859 return NULL;
41860 }
41861
41862
41863 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41864 PyObject *resultobj = 0;
41865 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41866 wxString *arg2 = 0 ;
41867 int result;
41868 void *argp1 = 0 ;
41869 int res1 = 0 ;
41870 bool temp2 = false ;
41871 PyObject * obj0 = 0 ;
41872 PyObject * obj1 = 0 ;
41873 char * kwnames[] = {
41874 (char *) "self",(char *) "title", NULL
41875 };
41876
41877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41879 if (!SWIG_IsOK(res1)) {
41880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41881 }
41882 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41883 {
41884 arg2 = wxString_in_helper(obj1);
41885 if (arg2 == NULL) SWIG_fail;
41886 temp2 = true;
41887 }
41888 {
41889 PyThreadState* __tstate = wxPyBeginAllowThreads();
41890 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41891 wxPyEndAllowThreads(__tstate);
41892 if (PyErr_Occurred()) SWIG_fail;
41893 }
41894 resultobj = SWIG_From_int(static_cast< int >(result));
41895 {
41896 if (temp2)
41897 delete arg2;
41898 }
41899 return resultobj;
41900 fail:
41901 {
41902 if (temp2)
41903 delete arg2;
41904 }
41905 return NULL;
41906 }
41907
41908
41909 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41910 PyObject *resultobj = 0;
41911 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41912 int arg2 ;
41913 bool arg3 ;
41914 void *argp1 = 0 ;
41915 int res1 = 0 ;
41916 int val2 ;
41917 int ecode2 = 0 ;
41918 bool val3 ;
41919 int ecode3 = 0 ;
41920 PyObject * obj0 = 0 ;
41921 PyObject * obj1 = 0 ;
41922 PyObject * obj2 = 0 ;
41923 char * kwnames[] = {
41924 (char *) "self",(char *) "id",(char *) "enable", NULL
41925 };
41926
41927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41929 if (!SWIG_IsOK(res1)) {
41930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41931 }
41932 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41933 ecode2 = SWIG_AsVal_int(obj1, &val2);
41934 if (!SWIG_IsOK(ecode2)) {
41935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41936 }
41937 arg2 = static_cast< int >(val2);
41938 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41939 if (!SWIG_IsOK(ecode3)) {
41940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41941 }
41942 arg3 = static_cast< bool >(val3);
41943 {
41944 PyThreadState* __tstate = wxPyBeginAllowThreads();
41945 (arg1)->Enable(arg2,arg3);
41946 wxPyEndAllowThreads(__tstate);
41947 if (PyErr_Occurred()) SWIG_fail;
41948 }
41949 resultobj = SWIG_Py_Void();
41950 return resultobj;
41951 fail:
41952 return NULL;
41953 }
41954
41955
41956 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41957 PyObject *resultobj = 0;
41958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41959 int arg2 ;
41960 bool arg3 ;
41961 void *argp1 = 0 ;
41962 int res1 = 0 ;
41963 int val2 ;
41964 int ecode2 = 0 ;
41965 bool val3 ;
41966 int ecode3 = 0 ;
41967 PyObject * obj0 = 0 ;
41968 PyObject * obj1 = 0 ;
41969 PyObject * obj2 = 0 ;
41970 char * kwnames[] = {
41971 (char *) "self",(char *) "id",(char *) "check", NULL
41972 };
41973
41974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41976 if (!SWIG_IsOK(res1)) {
41977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41978 }
41979 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41980 ecode2 = SWIG_AsVal_int(obj1, &val2);
41981 if (!SWIG_IsOK(ecode2)) {
41982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41983 }
41984 arg2 = static_cast< int >(val2);
41985 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41986 if (!SWIG_IsOK(ecode3)) {
41987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41988 }
41989 arg3 = static_cast< bool >(val3);
41990 {
41991 PyThreadState* __tstate = wxPyBeginAllowThreads();
41992 (arg1)->Check(arg2,arg3);
41993 wxPyEndAllowThreads(__tstate);
41994 if (PyErr_Occurred()) SWIG_fail;
41995 }
41996 resultobj = SWIG_Py_Void();
41997 return resultobj;
41998 fail:
41999 return NULL;
42000 }
42001
42002
42003 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42004 PyObject *resultobj = 0;
42005 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42006 int arg2 ;
42007 bool result;
42008 void *argp1 = 0 ;
42009 int res1 = 0 ;
42010 int val2 ;
42011 int ecode2 = 0 ;
42012 PyObject * obj0 = 0 ;
42013 PyObject * obj1 = 0 ;
42014 char * kwnames[] = {
42015 (char *) "self",(char *) "id", NULL
42016 };
42017
42018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42020 if (!SWIG_IsOK(res1)) {
42021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42022 }
42023 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42024 ecode2 = SWIG_AsVal_int(obj1, &val2);
42025 if (!SWIG_IsOK(ecode2)) {
42026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42027 }
42028 arg2 = static_cast< int >(val2);
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42032 wxPyEndAllowThreads(__tstate);
42033 if (PyErr_Occurred()) SWIG_fail;
42034 }
42035 {
42036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42037 }
42038 return resultobj;
42039 fail:
42040 return NULL;
42041 }
42042
42043
42044 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42045 PyObject *resultobj = 0;
42046 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42047 int arg2 ;
42048 bool result;
42049 void *argp1 = 0 ;
42050 int res1 = 0 ;
42051 int val2 ;
42052 int ecode2 = 0 ;
42053 PyObject * obj0 = 0 ;
42054 PyObject * obj1 = 0 ;
42055 char * kwnames[] = {
42056 (char *) "self",(char *) "id", NULL
42057 };
42058
42059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42061 if (!SWIG_IsOK(res1)) {
42062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42063 }
42064 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42065 ecode2 = SWIG_AsVal_int(obj1, &val2);
42066 if (!SWIG_IsOK(ecode2)) {
42067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42068 }
42069 arg2 = static_cast< int >(val2);
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42073 wxPyEndAllowThreads(__tstate);
42074 if (PyErr_Occurred()) SWIG_fail;
42075 }
42076 {
42077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42078 }
42079 return resultobj;
42080 fail:
42081 return NULL;
42082 }
42083
42084
42085 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42086 PyObject *resultobj = 0;
42087 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42088 int arg2 ;
42089 wxString *arg3 = 0 ;
42090 void *argp1 = 0 ;
42091 int res1 = 0 ;
42092 int val2 ;
42093 int ecode2 = 0 ;
42094 bool temp3 = false ;
42095 PyObject * obj0 = 0 ;
42096 PyObject * obj1 = 0 ;
42097 PyObject * obj2 = 0 ;
42098 char * kwnames[] = {
42099 (char *) "self",(char *) "id",(char *) "label", NULL
42100 };
42101
42102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42104 if (!SWIG_IsOK(res1)) {
42105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42106 }
42107 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42108 ecode2 = SWIG_AsVal_int(obj1, &val2);
42109 if (!SWIG_IsOK(ecode2)) {
42110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42111 }
42112 arg2 = static_cast< int >(val2);
42113 {
42114 arg3 = wxString_in_helper(obj2);
42115 if (arg3 == NULL) SWIG_fail;
42116 temp3 = true;
42117 }
42118 {
42119 PyThreadState* __tstate = wxPyBeginAllowThreads();
42120 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42121 wxPyEndAllowThreads(__tstate);
42122 if (PyErr_Occurred()) SWIG_fail;
42123 }
42124 resultobj = SWIG_Py_Void();
42125 {
42126 if (temp3)
42127 delete arg3;
42128 }
42129 return resultobj;
42130 fail:
42131 {
42132 if (temp3)
42133 delete arg3;
42134 }
42135 return NULL;
42136 }
42137
42138
42139 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42140 PyObject *resultobj = 0;
42141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42142 int arg2 ;
42143 wxString result;
42144 void *argp1 = 0 ;
42145 int res1 = 0 ;
42146 int val2 ;
42147 int ecode2 = 0 ;
42148 PyObject * obj0 = 0 ;
42149 PyObject * obj1 = 0 ;
42150 char * kwnames[] = {
42151 (char *) "self",(char *) "id", NULL
42152 };
42153
42154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42156 if (!SWIG_IsOK(res1)) {
42157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42158 }
42159 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42160 ecode2 = SWIG_AsVal_int(obj1, &val2);
42161 if (!SWIG_IsOK(ecode2)) {
42162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42163 }
42164 arg2 = static_cast< int >(val2);
42165 {
42166 PyThreadState* __tstate = wxPyBeginAllowThreads();
42167 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 {
42172 #if wxUSE_UNICODE
42173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42174 #else
42175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42176 #endif
42177 }
42178 return resultobj;
42179 fail:
42180 return NULL;
42181 }
42182
42183
42184 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42185 PyObject *resultobj = 0;
42186 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42187 int arg2 ;
42188 wxString *arg3 = 0 ;
42189 void *argp1 = 0 ;
42190 int res1 = 0 ;
42191 int val2 ;
42192 int ecode2 = 0 ;
42193 bool temp3 = false ;
42194 PyObject * obj0 = 0 ;
42195 PyObject * obj1 = 0 ;
42196 PyObject * obj2 = 0 ;
42197 char * kwnames[] = {
42198 (char *) "self",(char *) "id",(char *) "helpString", NULL
42199 };
42200
42201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42203 if (!SWIG_IsOK(res1)) {
42204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42205 }
42206 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42207 ecode2 = SWIG_AsVal_int(obj1, &val2);
42208 if (!SWIG_IsOK(ecode2)) {
42209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42210 }
42211 arg2 = static_cast< int >(val2);
42212 {
42213 arg3 = wxString_in_helper(obj2);
42214 if (arg3 == NULL) SWIG_fail;
42215 temp3 = true;
42216 }
42217 {
42218 PyThreadState* __tstate = wxPyBeginAllowThreads();
42219 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42220 wxPyEndAllowThreads(__tstate);
42221 if (PyErr_Occurred()) SWIG_fail;
42222 }
42223 resultobj = SWIG_Py_Void();
42224 {
42225 if (temp3)
42226 delete arg3;
42227 }
42228 return resultobj;
42229 fail:
42230 {
42231 if (temp3)
42232 delete arg3;
42233 }
42234 return NULL;
42235 }
42236
42237
42238 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42239 PyObject *resultobj = 0;
42240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42241 int arg2 ;
42242 wxString result;
42243 void *argp1 = 0 ;
42244 int res1 = 0 ;
42245 int val2 ;
42246 int ecode2 = 0 ;
42247 PyObject * obj0 = 0 ;
42248 PyObject * obj1 = 0 ;
42249 char * kwnames[] = {
42250 (char *) "self",(char *) "id", NULL
42251 };
42252
42253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42255 if (!SWIG_IsOK(res1)) {
42256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42257 }
42258 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42259 ecode2 = SWIG_AsVal_int(obj1, &val2);
42260 if (!SWIG_IsOK(ecode2)) {
42261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42262 }
42263 arg2 = static_cast< int >(val2);
42264 {
42265 PyThreadState* __tstate = wxPyBeginAllowThreads();
42266 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42267 wxPyEndAllowThreads(__tstate);
42268 if (PyErr_Occurred()) SWIG_fail;
42269 }
42270 {
42271 #if wxUSE_UNICODE
42272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42273 #else
42274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42275 #endif
42276 }
42277 return resultobj;
42278 fail:
42279 return NULL;
42280 }
42281
42282
42283 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42284 PyObject *resultobj = 0;
42285 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42286 wxFrame *result = 0 ;
42287 void *argp1 = 0 ;
42288 int res1 = 0 ;
42289 PyObject *swig_obj[1] ;
42290
42291 if (!args) SWIG_fail;
42292 swig_obj[0] = args;
42293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42294 if (!SWIG_IsOK(res1)) {
42295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42296 }
42297 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42298 {
42299 PyThreadState* __tstate = wxPyBeginAllowThreads();
42300 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 {
42305 resultobj = wxPyMake_wxObject(result, (bool)0);
42306 }
42307 return resultobj;
42308 fail:
42309 return NULL;
42310 }
42311
42312
42313 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42314 PyObject *resultobj = 0;
42315 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42316 bool result;
42317 void *argp1 = 0 ;
42318 int res1 = 0 ;
42319 PyObject *swig_obj[1] ;
42320
42321 if (!args) SWIG_fail;
42322 swig_obj[0] = args;
42323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42324 if (!SWIG_IsOK(res1)) {
42325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42326 }
42327 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42328 {
42329 PyThreadState* __tstate = wxPyBeginAllowThreads();
42330 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42331 wxPyEndAllowThreads(__tstate);
42332 if (PyErr_Occurred()) SWIG_fail;
42333 }
42334 {
42335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42336 }
42337 return resultobj;
42338 fail:
42339 return NULL;
42340 }
42341
42342
42343 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42344 PyObject *resultobj = 0;
42345 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42346 wxFrame *arg2 = (wxFrame *) 0 ;
42347 void *argp1 = 0 ;
42348 int res1 = 0 ;
42349 void *argp2 = 0 ;
42350 int res2 = 0 ;
42351 PyObject * obj0 = 0 ;
42352 PyObject * obj1 = 0 ;
42353 char * kwnames[] = {
42354 (char *) "self",(char *) "frame", NULL
42355 };
42356
42357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42359 if (!SWIG_IsOK(res1)) {
42360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42361 }
42362 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42364 if (!SWIG_IsOK(res2)) {
42365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42366 }
42367 arg2 = reinterpret_cast< wxFrame * >(argp2);
42368 {
42369 PyThreadState* __tstate = wxPyBeginAllowThreads();
42370 (arg1)->Attach(arg2);
42371 wxPyEndAllowThreads(__tstate);
42372 if (PyErr_Occurred()) SWIG_fail;
42373 }
42374 resultobj = SWIG_Py_Void();
42375 return resultobj;
42376 fail:
42377 return NULL;
42378 }
42379
42380
42381 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42382 PyObject *resultobj = 0;
42383 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42384 void *argp1 = 0 ;
42385 int res1 = 0 ;
42386 PyObject *swig_obj[1] ;
42387
42388 if (!args) SWIG_fail;
42389 swig_obj[0] = args;
42390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42391 if (!SWIG_IsOK(res1)) {
42392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42393 }
42394 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42395 {
42396 PyThreadState* __tstate = wxPyBeginAllowThreads();
42397 (arg1)->Detach();
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 resultobj = SWIG_Py_Void();
42402 return resultobj;
42403 fail:
42404 return NULL;
42405 }
42406
42407
42408 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42409 PyObject *resultobj = 0;
42410 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42411 void *argp1 = 0 ;
42412 int res1 = 0 ;
42413 PyObject *swig_obj[1] ;
42414
42415 if (!args) SWIG_fail;
42416 swig_obj[0] = args;
42417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42418 if (!SWIG_IsOK(res1)) {
42419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42420 }
42421 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 (arg1)->UpdateMenus();
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 resultobj = SWIG_Py_Void();
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42436 PyObject *resultobj = 0;
42437 bool arg1 ;
42438 bool val1 ;
42439 int ecode1 = 0 ;
42440 PyObject * obj0 = 0 ;
42441 char * kwnames[] = {
42442 (char *) "enable", NULL
42443 };
42444
42445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42446 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42447 if (!SWIG_IsOK(ecode1)) {
42448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42449 }
42450 arg1 = static_cast< bool >(val1);
42451 {
42452 PyThreadState* __tstate = wxPyBeginAllowThreads();
42453 wxMenuBar_SetAutoWindowMenu(arg1);
42454 wxPyEndAllowThreads(__tstate);
42455 if (PyErr_Occurred()) SWIG_fail;
42456 }
42457 resultobj = SWIG_Py_Void();
42458 return resultobj;
42459 fail:
42460 return NULL;
42461 }
42462
42463
42464 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42465 PyObject *resultobj = 0;
42466 bool result;
42467
42468 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42469 {
42470 PyThreadState* __tstate = wxPyBeginAllowThreads();
42471 result = (bool)wxMenuBar_GetAutoWindowMenu();
42472 wxPyEndAllowThreads(__tstate);
42473 if (PyErr_Occurred()) SWIG_fail;
42474 }
42475 {
42476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42477 }
42478 return resultobj;
42479 fail:
42480 return NULL;
42481 }
42482
42483
42484 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42485 PyObject *obj;
42486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42487 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42488 return SWIG_Py_Void();
42489 }
42490
42491 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42492 return SWIG_Python_InitShadowInstance(args);
42493 }
42494
42495 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42496 PyObject *resultobj = 0;
42497 wxMenu *arg1 = (wxMenu *) NULL ;
42498 int arg2 = (int) wxID_ANY ;
42499 wxString const &arg3_defvalue = wxPyEmptyString ;
42500 wxString *arg3 = (wxString *) &arg3_defvalue ;
42501 wxString const &arg4_defvalue = wxPyEmptyString ;
42502 wxString *arg4 = (wxString *) &arg4_defvalue ;
42503 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42504 wxMenu *arg6 = (wxMenu *) NULL ;
42505 wxMenuItem *result = 0 ;
42506 void *argp1 = 0 ;
42507 int res1 = 0 ;
42508 int val2 ;
42509 int ecode2 = 0 ;
42510 bool temp3 = false ;
42511 bool temp4 = false ;
42512 int val5 ;
42513 int ecode5 = 0 ;
42514 void *argp6 = 0 ;
42515 int res6 = 0 ;
42516 PyObject * obj0 = 0 ;
42517 PyObject * obj1 = 0 ;
42518 PyObject * obj2 = 0 ;
42519 PyObject * obj3 = 0 ;
42520 PyObject * obj4 = 0 ;
42521 PyObject * obj5 = 0 ;
42522 char * kwnames[] = {
42523 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42524 };
42525
42526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42527 if (obj0) {
42528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42529 if (!SWIG_IsOK(res1)) {
42530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42531 }
42532 arg1 = reinterpret_cast< wxMenu * >(argp1);
42533 }
42534 if (obj1) {
42535 ecode2 = SWIG_AsVal_int(obj1, &val2);
42536 if (!SWIG_IsOK(ecode2)) {
42537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42538 }
42539 arg2 = static_cast< int >(val2);
42540 }
42541 if (obj2) {
42542 {
42543 arg3 = wxString_in_helper(obj2);
42544 if (arg3 == NULL) SWIG_fail;
42545 temp3 = true;
42546 }
42547 }
42548 if (obj3) {
42549 {
42550 arg4 = wxString_in_helper(obj3);
42551 if (arg4 == NULL) SWIG_fail;
42552 temp4 = true;
42553 }
42554 }
42555 if (obj4) {
42556 ecode5 = SWIG_AsVal_int(obj4, &val5);
42557 if (!SWIG_IsOK(ecode5)) {
42558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42559 }
42560 arg5 = static_cast< wxItemKind >(val5);
42561 }
42562 if (obj5) {
42563 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42564 if (!SWIG_IsOK(res6)) {
42565 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42566 }
42567 arg6 = reinterpret_cast< wxMenu * >(argp6);
42568 }
42569 {
42570 PyThreadState* __tstate = wxPyBeginAllowThreads();
42571 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42572 wxPyEndAllowThreads(__tstate);
42573 if (PyErr_Occurred()) SWIG_fail;
42574 }
42575 {
42576 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42577 }
42578 {
42579 if (temp3)
42580 delete arg3;
42581 }
42582 {
42583 if (temp4)
42584 delete arg4;
42585 }
42586 return resultobj;
42587 fail:
42588 {
42589 if (temp3)
42590 delete arg3;
42591 }
42592 {
42593 if (temp4)
42594 delete arg4;
42595 }
42596 return NULL;
42597 }
42598
42599
42600 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42601 PyObject *resultobj = 0;
42602 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42603 void *argp1 = 0 ;
42604 int res1 = 0 ;
42605 PyObject *swig_obj[1] ;
42606
42607 if (!args) SWIG_fail;
42608 swig_obj[0] = args;
42609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42610 if (!SWIG_IsOK(res1)) {
42611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42612 }
42613 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 delete arg1;
42617
42618 wxPyEndAllowThreads(__tstate);
42619 if (PyErr_Occurred()) SWIG_fail;
42620 }
42621 resultobj = SWIG_Py_Void();
42622 return resultobj;
42623 fail:
42624 return NULL;
42625 }
42626
42627
42628 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42629 PyObject *resultobj = 0;
42630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42631 wxMenu *result = 0 ;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 PyObject *swig_obj[1] ;
42635
42636 if (!args) SWIG_fail;
42637 swig_obj[0] = args;
42638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42639 if (!SWIG_IsOK(res1)) {
42640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 {
42650 resultobj = wxPyMake_wxObject(result, 0);
42651 }
42652 return resultobj;
42653 fail:
42654 return NULL;
42655 }
42656
42657
42658 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42659 PyObject *resultobj = 0;
42660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42661 wxMenu *arg2 = (wxMenu *) 0 ;
42662 void *argp1 = 0 ;
42663 int res1 = 0 ;
42664 void *argp2 = 0 ;
42665 int res2 = 0 ;
42666 PyObject * obj0 = 0 ;
42667 PyObject * obj1 = 0 ;
42668 char * kwnames[] = {
42669 (char *) "self",(char *) "menu", NULL
42670 };
42671
42672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42674 if (!SWIG_IsOK(res1)) {
42675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42676 }
42677 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42679 if (!SWIG_IsOK(res2)) {
42680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42681 }
42682 arg2 = reinterpret_cast< wxMenu * >(argp2);
42683 {
42684 PyThreadState* __tstate = wxPyBeginAllowThreads();
42685 (arg1)->SetMenu(arg2);
42686 wxPyEndAllowThreads(__tstate);
42687 if (PyErr_Occurred()) SWIG_fail;
42688 }
42689 resultobj = SWIG_Py_Void();
42690 return resultobj;
42691 fail:
42692 return NULL;
42693 }
42694
42695
42696 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42697 PyObject *resultobj = 0;
42698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42699 int arg2 ;
42700 void *argp1 = 0 ;
42701 int res1 = 0 ;
42702 int val2 ;
42703 int ecode2 = 0 ;
42704 PyObject * obj0 = 0 ;
42705 PyObject * obj1 = 0 ;
42706 char * kwnames[] = {
42707 (char *) "self",(char *) "id", NULL
42708 };
42709
42710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42712 if (!SWIG_IsOK(res1)) {
42713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42714 }
42715 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42716 ecode2 = SWIG_AsVal_int(obj1, &val2);
42717 if (!SWIG_IsOK(ecode2)) {
42718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42719 }
42720 arg2 = static_cast< int >(val2);
42721 {
42722 PyThreadState* __tstate = wxPyBeginAllowThreads();
42723 (arg1)->SetId(arg2);
42724 wxPyEndAllowThreads(__tstate);
42725 if (PyErr_Occurred()) SWIG_fail;
42726 }
42727 resultobj = SWIG_Py_Void();
42728 return resultobj;
42729 fail:
42730 return NULL;
42731 }
42732
42733
42734 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42735 PyObject *resultobj = 0;
42736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42737 int result;
42738 void *argp1 = 0 ;
42739 int res1 = 0 ;
42740 PyObject *swig_obj[1] ;
42741
42742 if (!args) SWIG_fail;
42743 swig_obj[0] = args;
42744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42745 if (!SWIG_IsOK(res1)) {
42746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42747 }
42748 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42749 {
42750 PyThreadState* __tstate = wxPyBeginAllowThreads();
42751 result = (int)((wxMenuItem const *)arg1)->GetId();
42752 wxPyEndAllowThreads(__tstate);
42753 if (PyErr_Occurred()) SWIG_fail;
42754 }
42755 resultobj = SWIG_From_int(static_cast< int >(result));
42756 return resultobj;
42757 fail:
42758 return NULL;
42759 }
42760
42761
42762 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42763 PyObject *resultobj = 0;
42764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42765 bool result;
42766 void *argp1 = 0 ;
42767 int res1 = 0 ;
42768 PyObject *swig_obj[1] ;
42769
42770 if (!args) SWIG_fail;
42771 swig_obj[0] = args;
42772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42773 if (!SWIG_IsOK(res1)) {
42774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42775 }
42776 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42777 {
42778 PyThreadState* __tstate = wxPyBeginAllowThreads();
42779 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42780 wxPyEndAllowThreads(__tstate);
42781 if (PyErr_Occurred()) SWIG_fail;
42782 }
42783 {
42784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42785 }
42786 return resultobj;
42787 fail:
42788 return NULL;
42789 }
42790
42791
42792 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42793 PyObject *resultobj = 0;
42794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42795 wxString *arg2 = 0 ;
42796 void *argp1 = 0 ;
42797 int res1 = 0 ;
42798 bool temp2 = false ;
42799 PyObject * obj0 = 0 ;
42800 PyObject * obj1 = 0 ;
42801 char * kwnames[] = {
42802 (char *) "self",(char *) "str", NULL
42803 };
42804
42805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42807 if (!SWIG_IsOK(res1)) {
42808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42809 }
42810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42811 {
42812 arg2 = wxString_in_helper(obj1);
42813 if (arg2 == NULL) SWIG_fail;
42814 temp2 = true;
42815 }
42816 {
42817 PyThreadState* __tstate = wxPyBeginAllowThreads();
42818 (arg1)->SetText((wxString const &)*arg2);
42819 wxPyEndAllowThreads(__tstate);
42820 if (PyErr_Occurred()) SWIG_fail;
42821 }
42822 resultobj = SWIG_Py_Void();
42823 {
42824 if (temp2)
42825 delete arg2;
42826 }
42827 return resultobj;
42828 fail:
42829 {
42830 if (temp2)
42831 delete arg2;
42832 }
42833 return NULL;
42834 }
42835
42836
42837 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42838 PyObject *resultobj = 0;
42839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42840 wxString result;
42841 void *argp1 = 0 ;
42842 int res1 = 0 ;
42843 PyObject *swig_obj[1] ;
42844
42845 if (!args) SWIG_fail;
42846 swig_obj[0] = args;
42847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42848 if (!SWIG_IsOK(res1)) {
42849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42850 }
42851 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 result = ((wxMenuItem const *)arg1)->GetLabel();
42855 wxPyEndAllowThreads(__tstate);
42856 if (PyErr_Occurred()) SWIG_fail;
42857 }
42858 {
42859 #if wxUSE_UNICODE
42860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42861 #else
42862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42863 #endif
42864 }
42865 return resultobj;
42866 fail:
42867 return NULL;
42868 }
42869
42870
42871 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42872 PyObject *resultobj = 0;
42873 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42874 wxString *result = 0 ;
42875 void *argp1 = 0 ;
42876 int res1 = 0 ;
42877 PyObject *swig_obj[1] ;
42878
42879 if (!args) SWIG_fail;
42880 swig_obj[0] = args;
42881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42882 if (!SWIG_IsOK(res1)) {
42883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42884 }
42885 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 {
42889 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42890 result = (wxString *) &_result_ref;
42891 }
42892 wxPyEndAllowThreads(__tstate);
42893 if (PyErr_Occurred()) SWIG_fail;
42894 }
42895 {
42896 #if wxUSE_UNICODE
42897 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42898 #else
42899 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42900 #endif
42901 }
42902 return resultobj;
42903 fail:
42904 return NULL;
42905 }
42906
42907
42908 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42909 PyObject *resultobj = 0;
42910 wxString *arg1 = 0 ;
42911 wxString result;
42912 bool temp1 = false ;
42913 PyObject * obj0 = 0 ;
42914 char * kwnames[] = {
42915 (char *) "text", NULL
42916 };
42917
42918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42919 {
42920 arg1 = wxString_in_helper(obj0);
42921 if (arg1 == NULL) SWIG_fail;
42922 temp1 = true;
42923 }
42924 {
42925 PyThreadState* __tstate = wxPyBeginAllowThreads();
42926 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42927 wxPyEndAllowThreads(__tstate);
42928 if (PyErr_Occurred()) SWIG_fail;
42929 }
42930 {
42931 #if wxUSE_UNICODE
42932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42933 #else
42934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42935 #endif
42936 }
42937 {
42938 if (temp1)
42939 delete arg1;
42940 }
42941 return resultobj;
42942 fail:
42943 {
42944 if (temp1)
42945 delete arg1;
42946 }
42947 return NULL;
42948 }
42949
42950
42951 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42952 PyObject *resultobj = 0;
42953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42954 wxItemKind result;
42955 void *argp1 = 0 ;
42956 int res1 = 0 ;
42957 PyObject *swig_obj[1] ;
42958
42959 if (!args) SWIG_fail;
42960 swig_obj[0] = args;
42961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42962 if (!SWIG_IsOK(res1)) {
42963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42964 }
42965 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42966 {
42967 PyThreadState* __tstate = wxPyBeginAllowThreads();
42968 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42969 wxPyEndAllowThreads(__tstate);
42970 if (PyErr_Occurred()) SWIG_fail;
42971 }
42972 resultobj = SWIG_From_int(static_cast< int >(result));
42973 return resultobj;
42974 fail:
42975 return NULL;
42976 }
42977
42978
42979 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42980 PyObject *resultobj = 0;
42981 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42982 wxItemKind arg2 ;
42983 void *argp1 = 0 ;
42984 int res1 = 0 ;
42985 int val2 ;
42986 int ecode2 = 0 ;
42987 PyObject * obj0 = 0 ;
42988 PyObject * obj1 = 0 ;
42989 char * kwnames[] = {
42990 (char *) "self",(char *) "kind", NULL
42991 };
42992
42993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42995 if (!SWIG_IsOK(res1)) {
42996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42997 }
42998 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42999 ecode2 = SWIG_AsVal_int(obj1, &val2);
43000 if (!SWIG_IsOK(ecode2)) {
43001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43002 }
43003 arg2 = static_cast< wxItemKind >(val2);
43004 {
43005 PyThreadState* __tstate = wxPyBeginAllowThreads();
43006 (arg1)->SetKind(arg2);
43007 wxPyEndAllowThreads(__tstate);
43008 if (PyErr_Occurred()) SWIG_fail;
43009 }
43010 resultobj = SWIG_Py_Void();
43011 return resultobj;
43012 fail:
43013 return NULL;
43014 }
43015
43016
43017 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43018 PyObject *resultobj = 0;
43019 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43020 bool arg2 ;
43021 void *argp1 = 0 ;
43022 int res1 = 0 ;
43023 bool val2 ;
43024 int ecode2 = 0 ;
43025 PyObject * obj0 = 0 ;
43026 PyObject * obj1 = 0 ;
43027 char * kwnames[] = {
43028 (char *) "self",(char *) "checkable", NULL
43029 };
43030
43031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43033 if (!SWIG_IsOK(res1)) {
43034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43035 }
43036 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43037 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43038 if (!SWIG_IsOK(ecode2)) {
43039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43040 }
43041 arg2 = static_cast< bool >(val2);
43042 {
43043 PyThreadState* __tstate = wxPyBeginAllowThreads();
43044 (arg1)->SetCheckable(arg2);
43045 wxPyEndAllowThreads(__tstate);
43046 if (PyErr_Occurred()) SWIG_fail;
43047 }
43048 resultobj = SWIG_Py_Void();
43049 return resultobj;
43050 fail:
43051 return NULL;
43052 }
43053
43054
43055 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43056 PyObject *resultobj = 0;
43057 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43058 bool result;
43059 void *argp1 = 0 ;
43060 int res1 = 0 ;
43061 PyObject *swig_obj[1] ;
43062
43063 if (!args) SWIG_fail;
43064 swig_obj[0] = args;
43065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43066 if (!SWIG_IsOK(res1)) {
43067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43068 }
43069 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43070 {
43071 PyThreadState* __tstate = wxPyBeginAllowThreads();
43072 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43073 wxPyEndAllowThreads(__tstate);
43074 if (PyErr_Occurred()) SWIG_fail;
43075 }
43076 {
43077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43078 }
43079 return resultobj;
43080 fail:
43081 return NULL;
43082 }
43083
43084
43085 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43086 PyObject *resultobj = 0;
43087 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43088 bool result;
43089 void *argp1 = 0 ;
43090 int res1 = 0 ;
43091 PyObject *swig_obj[1] ;
43092
43093 if (!args) SWIG_fail;
43094 swig_obj[0] = args;
43095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43096 if (!SWIG_IsOK(res1)) {
43097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43098 }
43099 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43100 {
43101 PyThreadState* __tstate = wxPyBeginAllowThreads();
43102 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43103 wxPyEndAllowThreads(__tstate);
43104 if (PyErr_Occurred()) SWIG_fail;
43105 }
43106 {
43107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43108 }
43109 return resultobj;
43110 fail:
43111 return NULL;
43112 }
43113
43114
43115 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43116 PyObject *resultobj = 0;
43117 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43118 wxMenu *arg2 = (wxMenu *) 0 ;
43119 void *argp1 = 0 ;
43120 int res1 = 0 ;
43121 void *argp2 = 0 ;
43122 int res2 = 0 ;
43123 PyObject * obj0 = 0 ;
43124 PyObject * obj1 = 0 ;
43125 char * kwnames[] = {
43126 (char *) "self",(char *) "menu", NULL
43127 };
43128
43129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43131 if (!SWIG_IsOK(res1)) {
43132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43133 }
43134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43136 if (!SWIG_IsOK(res2)) {
43137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43138 }
43139 arg2 = reinterpret_cast< wxMenu * >(argp2);
43140 {
43141 PyThreadState* __tstate = wxPyBeginAllowThreads();
43142 (arg1)->SetSubMenu(arg2);
43143 wxPyEndAllowThreads(__tstate);
43144 if (PyErr_Occurred()) SWIG_fail;
43145 }
43146 resultobj = SWIG_Py_Void();
43147 return resultobj;
43148 fail:
43149 return NULL;
43150 }
43151
43152
43153 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43154 PyObject *resultobj = 0;
43155 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43156 wxMenu *result = 0 ;
43157 void *argp1 = 0 ;
43158 int res1 = 0 ;
43159 PyObject *swig_obj[1] ;
43160
43161 if (!args) SWIG_fail;
43162 swig_obj[0] = args;
43163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43164 if (!SWIG_IsOK(res1)) {
43165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43166 }
43167 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43168 {
43169 PyThreadState* __tstate = wxPyBeginAllowThreads();
43170 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43171 wxPyEndAllowThreads(__tstate);
43172 if (PyErr_Occurred()) SWIG_fail;
43173 }
43174 {
43175 resultobj = wxPyMake_wxObject(result, 0);
43176 }
43177 return resultobj;
43178 fail:
43179 return NULL;
43180 }
43181
43182
43183 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43184 PyObject *resultobj = 0;
43185 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43186 bool arg2 = (bool) true ;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 bool val2 ;
43190 int ecode2 = 0 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 char * kwnames[] = {
43194 (char *) "self",(char *) "enable", NULL
43195 };
43196
43197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43203 if (obj1) {
43204 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43205 if (!SWIG_IsOK(ecode2)) {
43206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43207 }
43208 arg2 = static_cast< bool >(val2);
43209 }
43210 {
43211 PyThreadState* __tstate = wxPyBeginAllowThreads();
43212 (arg1)->Enable(arg2);
43213 wxPyEndAllowThreads(__tstate);
43214 if (PyErr_Occurred()) SWIG_fail;
43215 }
43216 resultobj = SWIG_Py_Void();
43217 return resultobj;
43218 fail:
43219 return NULL;
43220 }
43221
43222
43223 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43224 PyObject *resultobj = 0;
43225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43226 bool result;
43227 void *argp1 = 0 ;
43228 int res1 = 0 ;
43229 PyObject *swig_obj[1] ;
43230
43231 if (!args) SWIG_fail;
43232 swig_obj[0] = args;
43233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43234 if (!SWIG_IsOK(res1)) {
43235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43236 }
43237 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43238 {
43239 PyThreadState* __tstate = wxPyBeginAllowThreads();
43240 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43241 wxPyEndAllowThreads(__tstate);
43242 if (PyErr_Occurred()) SWIG_fail;
43243 }
43244 {
43245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43246 }
43247 return resultobj;
43248 fail:
43249 return NULL;
43250 }
43251
43252
43253 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43254 PyObject *resultobj = 0;
43255 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43256 bool arg2 = (bool) true ;
43257 void *argp1 = 0 ;
43258 int res1 = 0 ;
43259 bool val2 ;
43260 int ecode2 = 0 ;
43261 PyObject * obj0 = 0 ;
43262 PyObject * obj1 = 0 ;
43263 char * kwnames[] = {
43264 (char *) "self",(char *) "check", NULL
43265 };
43266
43267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43269 if (!SWIG_IsOK(res1)) {
43270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43271 }
43272 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43273 if (obj1) {
43274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43275 if (!SWIG_IsOK(ecode2)) {
43276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43277 }
43278 arg2 = static_cast< bool >(val2);
43279 }
43280 {
43281 PyThreadState* __tstate = wxPyBeginAllowThreads();
43282 (arg1)->Check(arg2);
43283 wxPyEndAllowThreads(__tstate);
43284 if (PyErr_Occurred()) SWIG_fail;
43285 }
43286 resultobj = SWIG_Py_Void();
43287 return resultobj;
43288 fail:
43289 return NULL;
43290 }
43291
43292
43293 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43294 PyObject *resultobj = 0;
43295 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43296 bool result;
43297 void *argp1 = 0 ;
43298 int res1 = 0 ;
43299 PyObject *swig_obj[1] ;
43300
43301 if (!args) SWIG_fail;
43302 swig_obj[0] = args;
43303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43304 if (!SWIG_IsOK(res1)) {
43305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43306 }
43307 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43308 {
43309 PyThreadState* __tstate = wxPyBeginAllowThreads();
43310 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43311 wxPyEndAllowThreads(__tstate);
43312 if (PyErr_Occurred()) SWIG_fail;
43313 }
43314 {
43315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43316 }
43317 return resultobj;
43318 fail:
43319 return NULL;
43320 }
43321
43322
43323 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43324 PyObject *resultobj = 0;
43325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43326 void *argp1 = 0 ;
43327 int res1 = 0 ;
43328 PyObject *swig_obj[1] ;
43329
43330 if (!args) SWIG_fail;
43331 swig_obj[0] = args;
43332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43333 if (!SWIG_IsOK(res1)) {
43334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43335 }
43336 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43337 {
43338 PyThreadState* __tstate = wxPyBeginAllowThreads();
43339 (arg1)->Toggle();
43340 wxPyEndAllowThreads(__tstate);
43341 if (PyErr_Occurred()) SWIG_fail;
43342 }
43343 resultobj = SWIG_Py_Void();
43344 return resultobj;
43345 fail:
43346 return NULL;
43347 }
43348
43349
43350 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43351 PyObject *resultobj = 0;
43352 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43353 wxString *arg2 = 0 ;
43354 void *argp1 = 0 ;
43355 int res1 = 0 ;
43356 bool temp2 = false ;
43357 PyObject * obj0 = 0 ;
43358 PyObject * obj1 = 0 ;
43359 char * kwnames[] = {
43360 (char *) "self",(char *) "str", NULL
43361 };
43362
43363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43365 if (!SWIG_IsOK(res1)) {
43366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43367 }
43368 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43369 {
43370 arg2 = wxString_in_helper(obj1);
43371 if (arg2 == NULL) SWIG_fail;
43372 temp2 = true;
43373 }
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 (arg1)->SetHelp((wxString const &)*arg2);
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 resultobj = SWIG_Py_Void();
43381 {
43382 if (temp2)
43383 delete arg2;
43384 }
43385 return resultobj;
43386 fail:
43387 {
43388 if (temp2)
43389 delete arg2;
43390 }
43391 return NULL;
43392 }
43393
43394
43395 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43396 PyObject *resultobj = 0;
43397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43398 wxString *result = 0 ;
43399 void *argp1 = 0 ;
43400 int res1 = 0 ;
43401 PyObject *swig_obj[1] ;
43402
43403 if (!args) SWIG_fail;
43404 swig_obj[0] = args;
43405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43406 if (!SWIG_IsOK(res1)) {
43407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43408 }
43409 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43410 {
43411 PyThreadState* __tstate = wxPyBeginAllowThreads();
43412 {
43413 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43414 result = (wxString *) &_result_ref;
43415 }
43416 wxPyEndAllowThreads(__tstate);
43417 if (PyErr_Occurred()) SWIG_fail;
43418 }
43419 {
43420 #if wxUSE_UNICODE
43421 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43422 #else
43423 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43424 #endif
43425 }
43426 return resultobj;
43427 fail:
43428 return NULL;
43429 }
43430
43431
43432 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43433 PyObject *resultobj = 0;
43434 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43435 wxAcceleratorEntry *result = 0 ;
43436 void *argp1 = 0 ;
43437 int res1 = 0 ;
43438 PyObject *swig_obj[1] ;
43439
43440 if (!args) SWIG_fail;
43441 swig_obj[0] = args;
43442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43443 if (!SWIG_IsOK(res1)) {
43444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43445 }
43446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43447 {
43448 PyThreadState* __tstate = wxPyBeginAllowThreads();
43449 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43450 wxPyEndAllowThreads(__tstate);
43451 if (PyErr_Occurred()) SWIG_fail;
43452 }
43453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43454 return resultobj;
43455 fail:
43456 return NULL;
43457 }
43458
43459
43460 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43461 PyObject *resultobj = 0;
43462 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43463 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43464 void *argp1 = 0 ;
43465 int res1 = 0 ;
43466 void *argp2 = 0 ;
43467 int res2 = 0 ;
43468 PyObject * obj0 = 0 ;
43469 PyObject * obj1 = 0 ;
43470 char * kwnames[] = {
43471 (char *) "self",(char *) "accel", NULL
43472 };
43473
43474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43476 if (!SWIG_IsOK(res1)) {
43477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43478 }
43479 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43481 if (!SWIG_IsOK(res2)) {
43482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43483 }
43484 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43485 {
43486 PyThreadState* __tstate = wxPyBeginAllowThreads();
43487 (arg1)->SetAccel(arg2);
43488 wxPyEndAllowThreads(__tstate);
43489 if (PyErr_Occurred()) SWIG_fail;
43490 }
43491 resultobj = SWIG_Py_Void();
43492 return resultobj;
43493 fail:
43494 return NULL;
43495 }
43496
43497
43498 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43499 PyObject *resultobj = 0;
43500 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43501 wxBitmap *arg2 = 0 ;
43502 void *argp1 = 0 ;
43503 int res1 = 0 ;
43504 void *argp2 = 0 ;
43505 int res2 = 0 ;
43506 PyObject * obj0 = 0 ;
43507 PyObject * obj1 = 0 ;
43508 char * kwnames[] = {
43509 (char *) "self",(char *) "bitmap", NULL
43510 };
43511
43512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43514 if (!SWIG_IsOK(res1)) {
43515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43516 }
43517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43518 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43519 if (!SWIG_IsOK(res2)) {
43520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43521 }
43522 if (!argp2) {
43523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43524 }
43525 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43526 {
43527 PyThreadState* __tstate = wxPyBeginAllowThreads();
43528 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43529 wxPyEndAllowThreads(__tstate);
43530 if (PyErr_Occurred()) SWIG_fail;
43531 }
43532 resultobj = SWIG_Py_Void();
43533 return resultobj;
43534 fail:
43535 return NULL;
43536 }
43537
43538
43539 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43540 PyObject *resultobj = 0;
43541 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43542 wxBitmap *result = 0 ;
43543 void *argp1 = 0 ;
43544 int res1 = 0 ;
43545 PyObject *swig_obj[1] ;
43546
43547 if (!args) SWIG_fail;
43548 swig_obj[0] = args;
43549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43550 if (!SWIG_IsOK(res1)) {
43551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43552 }
43553 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43554 {
43555 PyThreadState* __tstate = wxPyBeginAllowThreads();
43556 {
43557 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43558 result = (wxBitmap *) &_result_ref;
43559 }
43560 wxPyEndAllowThreads(__tstate);
43561 if (PyErr_Occurred()) SWIG_fail;
43562 }
43563 {
43564 wxBitmap* resultptr = new wxBitmap(*result);
43565 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43566 }
43567 return resultobj;
43568 fail:
43569 return NULL;
43570 }
43571
43572
43573 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43574 PyObject *resultobj = 0;
43575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43576 wxFont *arg2 = 0 ;
43577 void *argp1 = 0 ;
43578 int res1 = 0 ;
43579 void *argp2 = 0 ;
43580 int res2 = 0 ;
43581 PyObject * obj0 = 0 ;
43582 PyObject * obj1 = 0 ;
43583 char * kwnames[] = {
43584 (char *) "self",(char *) "font", NULL
43585 };
43586
43587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43589 if (!SWIG_IsOK(res1)) {
43590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43591 }
43592 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43593 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43594 if (!SWIG_IsOK(res2)) {
43595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43596 }
43597 if (!argp2) {
43598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43599 }
43600 arg2 = reinterpret_cast< wxFont * >(argp2);
43601 {
43602 PyThreadState* __tstate = wxPyBeginAllowThreads();
43603 (arg1)->SetFont((wxFont const &)*arg2);
43604 wxPyEndAllowThreads(__tstate);
43605 if (PyErr_Occurred()) SWIG_fail;
43606 }
43607 resultobj = SWIG_Py_Void();
43608 return resultobj;
43609 fail:
43610 return NULL;
43611 }
43612
43613
43614 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43615 PyObject *resultobj = 0;
43616 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43617 wxFont result;
43618 void *argp1 = 0 ;
43619 int res1 = 0 ;
43620 PyObject *swig_obj[1] ;
43621
43622 if (!args) SWIG_fail;
43623 swig_obj[0] = args;
43624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43625 if (!SWIG_IsOK(res1)) {
43626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43627 }
43628 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 result = (arg1)->GetFont();
43632 wxPyEndAllowThreads(__tstate);
43633 if (PyErr_Occurred()) SWIG_fail;
43634 }
43635 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43636 return resultobj;
43637 fail:
43638 return NULL;
43639 }
43640
43641
43642 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43643 PyObject *resultobj = 0;
43644 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43645 wxColour *arg2 = 0 ;
43646 void *argp1 = 0 ;
43647 int res1 = 0 ;
43648 wxColour temp2 ;
43649 PyObject * obj0 = 0 ;
43650 PyObject * obj1 = 0 ;
43651 char * kwnames[] = {
43652 (char *) "self",(char *) "colText", NULL
43653 };
43654
43655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43657 if (!SWIG_IsOK(res1)) {
43658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43659 }
43660 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43661 {
43662 arg2 = &temp2;
43663 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43664 }
43665 {
43666 PyThreadState* __tstate = wxPyBeginAllowThreads();
43667 (arg1)->SetTextColour((wxColour const &)*arg2);
43668 wxPyEndAllowThreads(__tstate);
43669 if (PyErr_Occurred()) SWIG_fail;
43670 }
43671 resultobj = SWIG_Py_Void();
43672 return resultobj;
43673 fail:
43674 return NULL;
43675 }
43676
43677
43678 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43679 PyObject *resultobj = 0;
43680 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43681 wxColour result;
43682 void *argp1 = 0 ;
43683 int res1 = 0 ;
43684 PyObject *swig_obj[1] ;
43685
43686 if (!args) SWIG_fail;
43687 swig_obj[0] = args;
43688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43689 if (!SWIG_IsOK(res1)) {
43690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43691 }
43692 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43693 {
43694 PyThreadState* __tstate = wxPyBeginAllowThreads();
43695 result = (arg1)->GetTextColour();
43696 wxPyEndAllowThreads(__tstate);
43697 if (PyErr_Occurred()) SWIG_fail;
43698 }
43699 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43700 return resultobj;
43701 fail:
43702 return NULL;
43703 }
43704
43705
43706 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43707 PyObject *resultobj = 0;
43708 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43709 wxColour *arg2 = 0 ;
43710 void *argp1 = 0 ;
43711 int res1 = 0 ;
43712 wxColour temp2 ;
43713 PyObject * obj0 = 0 ;
43714 PyObject * obj1 = 0 ;
43715 char * kwnames[] = {
43716 (char *) "self",(char *) "colBack", NULL
43717 };
43718
43719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43721 if (!SWIG_IsOK(res1)) {
43722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43723 }
43724 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43725 {
43726 arg2 = &temp2;
43727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43728 }
43729 {
43730 PyThreadState* __tstate = wxPyBeginAllowThreads();
43731 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43732 wxPyEndAllowThreads(__tstate);
43733 if (PyErr_Occurred()) SWIG_fail;
43734 }
43735 resultobj = SWIG_Py_Void();
43736 return resultobj;
43737 fail:
43738 return NULL;
43739 }
43740
43741
43742 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43743 PyObject *resultobj = 0;
43744 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43745 wxColour result;
43746 void *argp1 = 0 ;
43747 int res1 = 0 ;
43748 PyObject *swig_obj[1] ;
43749
43750 if (!args) SWIG_fail;
43751 swig_obj[0] = args;
43752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43753 if (!SWIG_IsOK(res1)) {
43754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43755 }
43756 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43757 {
43758 PyThreadState* __tstate = wxPyBeginAllowThreads();
43759 result = (arg1)->GetBackgroundColour();
43760 wxPyEndAllowThreads(__tstate);
43761 if (PyErr_Occurred()) SWIG_fail;
43762 }
43763 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43764 return resultobj;
43765 fail:
43766 return NULL;
43767 }
43768
43769
43770 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43771 PyObject *resultobj = 0;
43772 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43773 wxBitmap *arg2 = 0 ;
43774 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43775 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43776 void *argp1 = 0 ;
43777 int res1 = 0 ;
43778 void *argp2 = 0 ;
43779 int res2 = 0 ;
43780 void *argp3 = 0 ;
43781 int res3 = 0 ;
43782 PyObject * obj0 = 0 ;
43783 PyObject * obj1 = 0 ;
43784 PyObject * obj2 = 0 ;
43785 char * kwnames[] = {
43786 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43787 };
43788
43789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43791 if (!SWIG_IsOK(res1)) {
43792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43793 }
43794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43795 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43796 if (!SWIG_IsOK(res2)) {
43797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43798 }
43799 if (!argp2) {
43800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43801 }
43802 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43803 if (obj2) {
43804 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43805 if (!SWIG_IsOK(res3)) {
43806 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43807 }
43808 if (!argp3) {
43809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43810 }
43811 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43812 }
43813 {
43814 PyThreadState* __tstate = wxPyBeginAllowThreads();
43815 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43816 wxPyEndAllowThreads(__tstate);
43817 if (PyErr_Occurred()) SWIG_fail;
43818 }
43819 resultobj = SWIG_Py_Void();
43820 return resultobj;
43821 fail:
43822 return NULL;
43823 }
43824
43825
43826 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43827 PyObject *resultobj = 0;
43828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43829 wxBitmap *arg2 = 0 ;
43830 void *argp1 = 0 ;
43831 int res1 = 0 ;
43832 void *argp2 = 0 ;
43833 int res2 = 0 ;
43834 PyObject * obj0 = 0 ;
43835 PyObject * obj1 = 0 ;
43836 char * kwnames[] = {
43837 (char *) "self",(char *) "bmpDisabled", NULL
43838 };
43839
43840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43842 if (!SWIG_IsOK(res1)) {
43843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43844 }
43845 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43847 if (!SWIG_IsOK(res2)) {
43848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43849 }
43850 if (!argp2) {
43851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43852 }
43853 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43854 {
43855 PyThreadState* __tstate = wxPyBeginAllowThreads();
43856 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43857 wxPyEndAllowThreads(__tstate);
43858 if (PyErr_Occurred()) SWIG_fail;
43859 }
43860 resultobj = SWIG_Py_Void();
43861 return resultobj;
43862 fail:
43863 return NULL;
43864 }
43865
43866
43867 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43868 PyObject *resultobj = 0;
43869 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43870 wxBitmap *result = 0 ;
43871 void *argp1 = 0 ;
43872 int res1 = 0 ;
43873 PyObject *swig_obj[1] ;
43874
43875 if (!args) SWIG_fail;
43876 swig_obj[0] = args;
43877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43878 if (!SWIG_IsOK(res1)) {
43879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43880 }
43881 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43882 {
43883 PyThreadState* __tstate = wxPyBeginAllowThreads();
43884 {
43885 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43886 result = (wxBitmap *) &_result_ref;
43887 }
43888 wxPyEndAllowThreads(__tstate);
43889 if (PyErr_Occurred()) SWIG_fail;
43890 }
43891 {
43892 wxBitmap* resultptr = new wxBitmap(*result);
43893 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43894 }
43895 return resultobj;
43896 fail:
43897 return NULL;
43898 }
43899
43900
43901 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43902 PyObject *resultobj = 0;
43903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43904 int arg2 ;
43905 void *argp1 = 0 ;
43906 int res1 = 0 ;
43907 int val2 ;
43908 int ecode2 = 0 ;
43909 PyObject * obj0 = 0 ;
43910 PyObject * obj1 = 0 ;
43911 char * kwnames[] = {
43912 (char *) "self",(char *) "nWidth", NULL
43913 };
43914
43915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43917 if (!SWIG_IsOK(res1)) {
43918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43919 }
43920 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43921 ecode2 = SWIG_AsVal_int(obj1, &val2);
43922 if (!SWIG_IsOK(ecode2)) {
43923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43924 }
43925 arg2 = static_cast< int >(val2);
43926 {
43927 PyThreadState* __tstate = wxPyBeginAllowThreads();
43928 (arg1)->SetMarginWidth(arg2);
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 resultobj = SWIG_Py_Void();
43933 return resultobj;
43934 fail:
43935 return NULL;
43936 }
43937
43938
43939 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43940 PyObject *resultobj = 0;
43941 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43942 int result;
43943 void *argp1 = 0 ;
43944 int res1 = 0 ;
43945 PyObject *swig_obj[1] ;
43946
43947 if (!args) SWIG_fail;
43948 swig_obj[0] = args;
43949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43950 if (!SWIG_IsOK(res1)) {
43951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43952 }
43953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 result = (int)(arg1)->GetMarginWidth();
43957 wxPyEndAllowThreads(__tstate);
43958 if (PyErr_Occurred()) SWIG_fail;
43959 }
43960 resultobj = SWIG_From_int(static_cast< int >(result));
43961 return resultobj;
43962 fail:
43963 return NULL;
43964 }
43965
43966
43967 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43968 PyObject *resultobj = 0;
43969 int result;
43970
43971 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43972 {
43973 PyThreadState* __tstate = wxPyBeginAllowThreads();
43974 result = (int)wxMenuItem::GetDefaultMarginWidth();
43975 wxPyEndAllowThreads(__tstate);
43976 if (PyErr_Occurred()) SWIG_fail;
43977 }
43978 resultobj = SWIG_From_int(static_cast< int >(result));
43979 return resultobj;
43980 fail:
43981 return NULL;
43982 }
43983
43984
43985 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43986 PyObject *resultobj = 0;
43987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43988 bool result;
43989 void *argp1 = 0 ;
43990 int res1 = 0 ;
43991 PyObject *swig_obj[1] ;
43992
43993 if (!args) SWIG_fail;
43994 swig_obj[0] = args;
43995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43996 if (!SWIG_IsOK(res1)) {
43997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43998 }
43999 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44000 {
44001 PyThreadState* __tstate = wxPyBeginAllowThreads();
44002 result = (bool)(arg1)->IsOwnerDrawn();
44003 wxPyEndAllowThreads(__tstate);
44004 if (PyErr_Occurred()) SWIG_fail;
44005 }
44006 {
44007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44008 }
44009 return resultobj;
44010 fail:
44011 return NULL;
44012 }
44013
44014
44015 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44016 PyObject *resultobj = 0;
44017 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44018 bool arg2 = (bool) true ;
44019 void *argp1 = 0 ;
44020 int res1 = 0 ;
44021 bool val2 ;
44022 int ecode2 = 0 ;
44023 PyObject * obj0 = 0 ;
44024 PyObject * obj1 = 0 ;
44025 char * kwnames[] = {
44026 (char *) "self",(char *) "ownerDrawn", NULL
44027 };
44028
44029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44031 if (!SWIG_IsOK(res1)) {
44032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44033 }
44034 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44035 if (obj1) {
44036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44037 if (!SWIG_IsOK(ecode2)) {
44038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44039 }
44040 arg2 = static_cast< bool >(val2);
44041 }
44042 {
44043 PyThreadState* __tstate = wxPyBeginAllowThreads();
44044 (arg1)->SetOwnerDrawn(arg2);
44045 wxPyEndAllowThreads(__tstate);
44046 if (PyErr_Occurred()) SWIG_fail;
44047 }
44048 resultobj = SWIG_Py_Void();
44049 return resultobj;
44050 fail:
44051 return NULL;
44052 }
44053
44054
44055 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44056 PyObject *resultobj = 0;
44057 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44058 void *argp1 = 0 ;
44059 int res1 = 0 ;
44060 PyObject *swig_obj[1] ;
44061
44062 if (!args) SWIG_fail;
44063 swig_obj[0] = args;
44064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44065 if (!SWIG_IsOK(res1)) {
44066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44067 }
44068 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44069 {
44070 PyThreadState* __tstate = wxPyBeginAllowThreads();
44071 (arg1)->ResetOwnerDrawn();
44072 wxPyEndAllowThreads(__tstate);
44073 if (PyErr_Occurred()) SWIG_fail;
44074 }
44075 resultobj = SWIG_Py_Void();
44076 return resultobj;
44077 fail:
44078 return NULL;
44079 }
44080
44081
44082 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44083 PyObject *obj;
44084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44085 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44086 return SWIG_Py_Void();
44087 }
44088
44089 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44090 return SWIG_Python_InitShadowInstance(args);
44091 }
44092
44093 SWIGINTERN int ControlNameStr_set(PyObject *) {
44094 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44095 return 1;
44096 }
44097
44098
44099 SWIGINTERN PyObject *ControlNameStr_get(void) {
44100 PyObject *pyobj = 0;
44101
44102 {
44103 #if wxUSE_UNICODE
44104 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44105 #else
44106 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44107 #endif
44108 }
44109 return pyobj;
44110 }
44111
44112
44113 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44114 PyObject *resultobj = 0;
44115 wxWindow *arg1 = (wxWindow *) 0 ;
44116 int arg2 = (int) -1 ;
44117 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44118 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44119 wxSize const &arg4_defvalue = wxDefaultSize ;
44120 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44121 long arg5 = (long) 0 ;
44122 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44123 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44124 wxString const &arg7_defvalue = wxPyControlNameStr ;
44125 wxString *arg7 = (wxString *) &arg7_defvalue ;
44126 wxControl *result = 0 ;
44127 void *argp1 = 0 ;
44128 int res1 = 0 ;
44129 int val2 ;
44130 int ecode2 = 0 ;
44131 wxPoint temp3 ;
44132 wxSize temp4 ;
44133 long val5 ;
44134 int ecode5 = 0 ;
44135 void *argp6 = 0 ;
44136 int res6 = 0 ;
44137 bool temp7 = false ;
44138 PyObject * obj0 = 0 ;
44139 PyObject * obj1 = 0 ;
44140 PyObject * obj2 = 0 ;
44141 PyObject * obj3 = 0 ;
44142 PyObject * obj4 = 0 ;
44143 PyObject * obj5 = 0 ;
44144 PyObject * obj6 = 0 ;
44145 char * kwnames[] = {
44146 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44147 };
44148
44149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44151 if (!SWIG_IsOK(res1)) {
44152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44153 }
44154 arg1 = reinterpret_cast< wxWindow * >(argp1);
44155 if (obj1) {
44156 ecode2 = SWIG_AsVal_int(obj1, &val2);
44157 if (!SWIG_IsOK(ecode2)) {
44158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44159 }
44160 arg2 = static_cast< int >(val2);
44161 }
44162 if (obj2) {
44163 {
44164 arg3 = &temp3;
44165 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44166 }
44167 }
44168 if (obj3) {
44169 {
44170 arg4 = &temp4;
44171 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44172 }
44173 }
44174 if (obj4) {
44175 ecode5 = SWIG_AsVal_long(obj4, &val5);
44176 if (!SWIG_IsOK(ecode5)) {
44177 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44178 }
44179 arg5 = static_cast< long >(val5);
44180 }
44181 if (obj5) {
44182 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44183 if (!SWIG_IsOK(res6)) {
44184 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44185 }
44186 if (!argp6) {
44187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44188 }
44189 arg6 = reinterpret_cast< wxValidator * >(argp6);
44190 }
44191 if (obj6) {
44192 {
44193 arg7 = wxString_in_helper(obj6);
44194 if (arg7 == NULL) SWIG_fail;
44195 temp7 = true;
44196 }
44197 }
44198 {
44199 if (!wxPyCheckForApp()) SWIG_fail;
44200 PyThreadState* __tstate = wxPyBeginAllowThreads();
44201 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44202 wxPyEndAllowThreads(__tstate);
44203 if (PyErr_Occurred()) SWIG_fail;
44204 }
44205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44206 {
44207 if (temp7)
44208 delete arg7;
44209 }
44210 return resultobj;
44211 fail:
44212 {
44213 if (temp7)
44214 delete arg7;
44215 }
44216 return NULL;
44217 }
44218
44219
44220 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44221 PyObject *resultobj = 0;
44222 wxControl *result = 0 ;
44223
44224 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44225 {
44226 if (!wxPyCheckForApp()) SWIG_fail;
44227 PyThreadState* __tstate = wxPyBeginAllowThreads();
44228 result = (wxControl *)new wxControl();
44229 wxPyEndAllowThreads(__tstate);
44230 if (PyErr_Occurred()) SWIG_fail;
44231 }
44232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44233 return resultobj;
44234 fail:
44235 return NULL;
44236 }
44237
44238
44239 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44240 PyObject *resultobj = 0;
44241 wxControl *arg1 = (wxControl *) 0 ;
44242 wxWindow *arg2 = (wxWindow *) 0 ;
44243 int arg3 = (int) -1 ;
44244 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44245 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44246 wxSize const &arg5_defvalue = wxDefaultSize ;
44247 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44248 long arg6 = (long) 0 ;
44249 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44250 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44251 wxString const &arg8_defvalue = wxPyControlNameStr ;
44252 wxString *arg8 = (wxString *) &arg8_defvalue ;
44253 bool result;
44254 void *argp1 = 0 ;
44255 int res1 = 0 ;
44256 void *argp2 = 0 ;
44257 int res2 = 0 ;
44258 int val3 ;
44259 int ecode3 = 0 ;
44260 wxPoint temp4 ;
44261 wxSize temp5 ;
44262 long val6 ;
44263 int ecode6 = 0 ;
44264 void *argp7 = 0 ;
44265 int res7 = 0 ;
44266 bool temp8 = false ;
44267 PyObject * obj0 = 0 ;
44268 PyObject * obj1 = 0 ;
44269 PyObject * obj2 = 0 ;
44270 PyObject * obj3 = 0 ;
44271 PyObject * obj4 = 0 ;
44272 PyObject * obj5 = 0 ;
44273 PyObject * obj6 = 0 ;
44274 PyObject * obj7 = 0 ;
44275 char * kwnames[] = {
44276 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44277 };
44278
44279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44281 if (!SWIG_IsOK(res1)) {
44282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44283 }
44284 arg1 = reinterpret_cast< wxControl * >(argp1);
44285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44286 if (!SWIG_IsOK(res2)) {
44287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44288 }
44289 arg2 = reinterpret_cast< wxWindow * >(argp2);
44290 if (obj2) {
44291 ecode3 = SWIG_AsVal_int(obj2, &val3);
44292 if (!SWIG_IsOK(ecode3)) {
44293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44294 }
44295 arg3 = static_cast< int >(val3);
44296 }
44297 if (obj3) {
44298 {
44299 arg4 = &temp4;
44300 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44301 }
44302 }
44303 if (obj4) {
44304 {
44305 arg5 = &temp5;
44306 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44307 }
44308 }
44309 if (obj5) {
44310 ecode6 = SWIG_AsVal_long(obj5, &val6);
44311 if (!SWIG_IsOK(ecode6)) {
44312 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44313 }
44314 arg6 = static_cast< long >(val6);
44315 }
44316 if (obj6) {
44317 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44318 if (!SWIG_IsOK(res7)) {
44319 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44320 }
44321 if (!argp7) {
44322 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44323 }
44324 arg7 = reinterpret_cast< wxValidator * >(argp7);
44325 }
44326 if (obj7) {
44327 {
44328 arg8 = wxString_in_helper(obj7);
44329 if (arg8 == NULL) SWIG_fail;
44330 temp8 = true;
44331 }
44332 }
44333 {
44334 PyThreadState* __tstate = wxPyBeginAllowThreads();
44335 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44336 wxPyEndAllowThreads(__tstate);
44337 if (PyErr_Occurred()) SWIG_fail;
44338 }
44339 {
44340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44341 }
44342 {
44343 if (temp8)
44344 delete arg8;
44345 }
44346 return resultobj;
44347 fail:
44348 {
44349 if (temp8)
44350 delete arg8;
44351 }
44352 return NULL;
44353 }
44354
44355
44356 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44357 PyObject *resultobj = 0;
44358 wxControl *arg1 = (wxControl *) 0 ;
44359 int result;
44360 void *argp1 = 0 ;
44361 int res1 = 0 ;
44362 PyObject *swig_obj[1] ;
44363
44364 if (!args) SWIG_fail;
44365 swig_obj[0] = args;
44366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44367 if (!SWIG_IsOK(res1)) {
44368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44369 }
44370 arg1 = reinterpret_cast< wxControl * >(argp1);
44371 {
44372 PyThreadState* __tstate = wxPyBeginAllowThreads();
44373 result = (int)((wxControl const *)arg1)->GetAlignment();
44374 wxPyEndAllowThreads(__tstate);
44375 if (PyErr_Occurred()) SWIG_fail;
44376 }
44377 resultobj = SWIG_From_int(static_cast< int >(result));
44378 return resultobj;
44379 fail:
44380 return NULL;
44381 }
44382
44383
44384 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44385 PyObject *resultobj = 0;
44386 wxControl *arg1 = (wxControl *) 0 ;
44387 wxString result;
44388 void *argp1 = 0 ;
44389 int res1 = 0 ;
44390 PyObject *swig_obj[1] ;
44391
44392 if (!args) SWIG_fail;
44393 swig_obj[0] = args;
44394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44395 if (!SWIG_IsOK(res1)) {
44396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44397 }
44398 arg1 = reinterpret_cast< wxControl * >(argp1);
44399 {
44400 PyThreadState* __tstate = wxPyBeginAllowThreads();
44401 result = ((wxControl const *)arg1)->GetLabelText();
44402 wxPyEndAllowThreads(__tstate);
44403 if (PyErr_Occurred()) SWIG_fail;
44404 }
44405 {
44406 #if wxUSE_UNICODE
44407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44408 #else
44409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44410 #endif
44411 }
44412 return resultobj;
44413 fail:
44414 return NULL;
44415 }
44416
44417
44418 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44419 PyObject *resultobj = 0;
44420 wxControl *arg1 = (wxControl *) 0 ;
44421 wxCommandEvent *arg2 = 0 ;
44422 void *argp1 = 0 ;
44423 int res1 = 0 ;
44424 void *argp2 = 0 ;
44425 int res2 = 0 ;
44426 PyObject * obj0 = 0 ;
44427 PyObject * obj1 = 0 ;
44428 char * kwnames[] = {
44429 (char *) "self",(char *) "event", NULL
44430 };
44431
44432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44434 if (!SWIG_IsOK(res1)) {
44435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44436 }
44437 arg1 = reinterpret_cast< wxControl * >(argp1);
44438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44439 if (!SWIG_IsOK(res2)) {
44440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44441 }
44442 if (!argp2) {
44443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44444 }
44445 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 (arg1)->Command(*arg2);
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_Py_Void();
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44460 PyObject *resultobj = 0;
44461 wxControl *arg1 = (wxControl *) 0 ;
44462 wxString result;
44463 void *argp1 = 0 ;
44464 int res1 = 0 ;
44465 PyObject *swig_obj[1] ;
44466
44467 if (!args) SWIG_fail;
44468 swig_obj[0] = args;
44469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44470 if (!SWIG_IsOK(res1)) {
44471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44472 }
44473 arg1 = reinterpret_cast< wxControl * >(argp1);
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 result = (arg1)->GetLabel();
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 {
44481 #if wxUSE_UNICODE
44482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44483 #else
44484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44485 #endif
44486 }
44487 return resultobj;
44488 fail:
44489 return NULL;
44490 }
44491
44492
44493 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44494 PyObject *resultobj = 0;
44495 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44496 SwigValueWrapper<wxVisualAttributes > result;
44497 int val1 ;
44498 int ecode1 = 0 ;
44499 PyObject * obj0 = 0 ;
44500 char * kwnames[] = {
44501 (char *) "variant", NULL
44502 };
44503
44504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44505 if (obj0) {
44506 ecode1 = SWIG_AsVal_int(obj0, &val1);
44507 if (!SWIG_IsOK(ecode1)) {
44508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44509 }
44510 arg1 = static_cast< wxWindowVariant >(val1);
44511 }
44512 {
44513 if (!wxPyCheckForApp()) SWIG_fail;
44514 PyThreadState* __tstate = wxPyBeginAllowThreads();
44515 result = wxControl::GetClassDefaultAttributes(arg1);
44516 wxPyEndAllowThreads(__tstate);
44517 if (PyErr_Occurred()) SWIG_fail;
44518 }
44519 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44520 return resultobj;
44521 fail:
44522 return NULL;
44523 }
44524
44525
44526 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44527 PyObject *obj;
44528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44529 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44530 return SWIG_Py_Void();
44531 }
44532
44533 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44534 return SWIG_Python_InitShadowInstance(args);
44535 }
44536
44537 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44538 PyObject *resultobj = 0;
44539 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44540 wxString *arg2 = 0 ;
44541 PyObject *arg3 = (PyObject *) NULL ;
44542 int result;
44543 void *argp1 = 0 ;
44544 int res1 = 0 ;
44545 bool temp2 = false ;
44546 PyObject * obj0 = 0 ;
44547 PyObject * obj1 = 0 ;
44548 PyObject * obj2 = 0 ;
44549 char * kwnames[] = {
44550 (char *) "self",(char *) "item",(char *) "clientData", NULL
44551 };
44552
44553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44555 if (!SWIG_IsOK(res1)) {
44556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44557 }
44558 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44559 {
44560 arg2 = wxString_in_helper(obj1);
44561 if (arg2 == NULL) SWIG_fail;
44562 temp2 = true;
44563 }
44564 if (obj2) {
44565 arg3 = obj2;
44566 }
44567 {
44568 PyThreadState* __tstate = wxPyBeginAllowThreads();
44569 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44570 wxPyEndAllowThreads(__tstate);
44571 if (PyErr_Occurred()) SWIG_fail;
44572 }
44573 resultobj = SWIG_From_int(static_cast< int >(result));
44574 {
44575 if (temp2)
44576 delete arg2;
44577 }
44578 return resultobj;
44579 fail:
44580 {
44581 if (temp2)
44582 delete arg2;
44583 }
44584 return NULL;
44585 }
44586
44587
44588 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44589 PyObject *resultobj = 0;
44590 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44591 wxArrayString *arg2 = 0 ;
44592 void *argp1 = 0 ;
44593 int res1 = 0 ;
44594 bool temp2 = false ;
44595 PyObject * obj0 = 0 ;
44596 PyObject * obj1 = 0 ;
44597 char * kwnames[] = {
44598 (char *) "self",(char *) "strings", NULL
44599 };
44600
44601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44603 if (!SWIG_IsOK(res1)) {
44604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44605 }
44606 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44607 {
44608 if (! PySequence_Check(obj1)) {
44609 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44610 SWIG_fail;
44611 }
44612 arg2 = new wxArrayString;
44613 temp2 = true;
44614 int i, len=PySequence_Length(obj1);
44615 for (i=0; i<len; i++) {
44616 PyObject* item = PySequence_GetItem(obj1, i);
44617 wxString* s = wxString_in_helper(item);
44618 if (PyErr_Occurred()) SWIG_fail;
44619 arg2->Add(*s);
44620 delete s;
44621 Py_DECREF(item);
44622 }
44623 }
44624 {
44625 PyThreadState* __tstate = wxPyBeginAllowThreads();
44626 (arg1)->Append((wxArrayString const &)*arg2);
44627 wxPyEndAllowThreads(__tstate);
44628 if (PyErr_Occurred()) SWIG_fail;
44629 }
44630 resultobj = SWIG_Py_Void();
44631 {
44632 if (temp2) delete arg2;
44633 }
44634 return resultobj;
44635 fail:
44636 {
44637 if (temp2) delete arg2;
44638 }
44639 return NULL;
44640 }
44641
44642
44643 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44644 PyObject *resultobj = 0;
44645 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44646 wxString *arg2 = 0 ;
44647 unsigned int arg3 ;
44648 PyObject *arg4 = (PyObject *) NULL ;
44649 int result;
44650 void *argp1 = 0 ;
44651 int res1 = 0 ;
44652 bool temp2 = false ;
44653 unsigned int val3 ;
44654 int ecode3 = 0 ;
44655 PyObject * obj0 = 0 ;
44656 PyObject * obj1 = 0 ;
44657 PyObject * obj2 = 0 ;
44658 PyObject * obj3 = 0 ;
44659 char * kwnames[] = {
44660 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44661 };
44662
44663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44665 if (!SWIG_IsOK(res1)) {
44666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44667 }
44668 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44669 {
44670 arg2 = wxString_in_helper(obj1);
44671 if (arg2 == NULL) SWIG_fail;
44672 temp2 = true;
44673 }
44674 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44675 if (!SWIG_IsOK(ecode3)) {
44676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44677 }
44678 arg3 = static_cast< unsigned int >(val3);
44679 if (obj3) {
44680 arg4 = obj3;
44681 }
44682 {
44683 PyThreadState* __tstate = wxPyBeginAllowThreads();
44684 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44685 wxPyEndAllowThreads(__tstate);
44686 if (PyErr_Occurred()) SWIG_fail;
44687 }
44688 resultobj = SWIG_From_int(static_cast< int >(result));
44689 {
44690 if (temp2)
44691 delete arg2;
44692 }
44693 return resultobj;
44694 fail:
44695 {
44696 if (temp2)
44697 delete arg2;
44698 }
44699 return NULL;
44700 }
44701
44702
44703 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44704 PyObject *resultobj = 0;
44705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44706 void *argp1 = 0 ;
44707 int res1 = 0 ;
44708 PyObject *swig_obj[1] ;
44709
44710 if (!args) SWIG_fail;
44711 swig_obj[0] = args;
44712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44713 if (!SWIG_IsOK(res1)) {
44714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44715 }
44716 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44717 {
44718 PyThreadState* __tstate = wxPyBeginAllowThreads();
44719 (arg1)->Clear();
44720 wxPyEndAllowThreads(__tstate);
44721 if (PyErr_Occurred()) SWIG_fail;
44722 }
44723 resultobj = SWIG_Py_Void();
44724 return resultobj;
44725 fail:
44726 return NULL;
44727 }
44728
44729
44730 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44731 PyObject *resultobj = 0;
44732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44733 unsigned int arg2 ;
44734 void *argp1 = 0 ;
44735 int res1 = 0 ;
44736 unsigned int val2 ;
44737 int ecode2 = 0 ;
44738 PyObject * obj0 = 0 ;
44739 PyObject * obj1 = 0 ;
44740 char * kwnames[] = {
44741 (char *) "self",(char *) "n", NULL
44742 };
44743
44744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44746 if (!SWIG_IsOK(res1)) {
44747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44748 }
44749 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44750 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44751 if (!SWIG_IsOK(ecode2)) {
44752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44753 }
44754 arg2 = static_cast< unsigned int >(val2);
44755 {
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 (arg1)->Delete(arg2);
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 resultobj = SWIG_Py_Void();
44762 return resultobj;
44763 fail:
44764 return NULL;
44765 }
44766
44767
44768 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44769 PyObject *resultobj = 0;
44770 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44771 unsigned int arg2 ;
44772 PyObject *result = 0 ;
44773 void *argp1 = 0 ;
44774 int res1 = 0 ;
44775 unsigned int val2 ;
44776 int ecode2 = 0 ;
44777 PyObject * obj0 = 0 ;
44778 PyObject * obj1 = 0 ;
44779 char * kwnames[] = {
44780 (char *) "self",(char *) "n", NULL
44781 };
44782
44783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44785 if (!SWIG_IsOK(res1)) {
44786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44787 }
44788 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44789 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44790 if (!SWIG_IsOK(ecode2)) {
44791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44792 }
44793 arg2 = static_cast< unsigned int >(val2);
44794 {
44795 PyThreadState* __tstate = wxPyBeginAllowThreads();
44796 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44797 wxPyEndAllowThreads(__tstate);
44798 if (PyErr_Occurred()) SWIG_fail;
44799 }
44800 resultobj = result;
44801 return resultobj;
44802 fail:
44803 return NULL;
44804 }
44805
44806
44807 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44808 PyObject *resultobj = 0;
44809 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44810 unsigned int arg2 ;
44811 PyObject *arg3 = (PyObject *) 0 ;
44812 void *argp1 = 0 ;
44813 int res1 = 0 ;
44814 unsigned int val2 ;
44815 int ecode2 = 0 ;
44816 PyObject * obj0 = 0 ;
44817 PyObject * obj1 = 0 ;
44818 PyObject * obj2 = 0 ;
44819 char * kwnames[] = {
44820 (char *) "self",(char *) "n",(char *) "clientData", NULL
44821 };
44822
44823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44825 if (!SWIG_IsOK(res1)) {
44826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44827 }
44828 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44829 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44830 if (!SWIG_IsOK(ecode2)) {
44831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44832 }
44833 arg2 = static_cast< unsigned int >(val2);
44834 arg3 = obj2;
44835 {
44836 PyThreadState* __tstate = wxPyBeginAllowThreads();
44837 wxItemContainer_SetClientData(arg1,arg2,arg3);
44838 wxPyEndAllowThreads(__tstate);
44839 if (PyErr_Occurred()) SWIG_fail;
44840 }
44841 resultobj = SWIG_Py_Void();
44842 return resultobj;
44843 fail:
44844 return NULL;
44845 }
44846
44847
44848 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44849 PyObject *resultobj = 0;
44850 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44851 unsigned int result;
44852 void *argp1 = 0 ;
44853 int res1 = 0 ;
44854 PyObject *swig_obj[1] ;
44855
44856 if (!args) SWIG_fail;
44857 swig_obj[0] = args;
44858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44859 if (!SWIG_IsOK(res1)) {
44860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44861 }
44862 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44863 {
44864 PyThreadState* __tstate = wxPyBeginAllowThreads();
44865 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44866 wxPyEndAllowThreads(__tstate);
44867 if (PyErr_Occurred()) SWIG_fail;
44868 }
44869 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44870 return resultobj;
44871 fail:
44872 return NULL;
44873 }
44874
44875
44876 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44877 PyObject *resultobj = 0;
44878 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44879 bool result;
44880 void *argp1 = 0 ;
44881 int res1 = 0 ;
44882 PyObject *swig_obj[1] ;
44883
44884 if (!args) SWIG_fail;
44885 swig_obj[0] = args;
44886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44887 if (!SWIG_IsOK(res1)) {
44888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44889 }
44890 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44891 {
44892 PyThreadState* __tstate = wxPyBeginAllowThreads();
44893 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44894 wxPyEndAllowThreads(__tstate);
44895 if (PyErr_Occurred()) SWIG_fail;
44896 }
44897 {
44898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44899 }
44900 return resultobj;
44901 fail:
44902 return NULL;
44903 }
44904
44905
44906 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44907 PyObject *resultobj = 0;
44908 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44909 unsigned int arg2 ;
44910 wxString result;
44911 void *argp1 = 0 ;
44912 int res1 = 0 ;
44913 unsigned int val2 ;
44914 int ecode2 = 0 ;
44915 PyObject * obj0 = 0 ;
44916 PyObject * obj1 = 0 ;
44917 char * kwnames[] = {
44918 (char *) "self",(char *) "n", NULL
44919 };
44920
44921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44923 if (!SWIG_IsOK(res1)) {
44924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44925 }
44926 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44927 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44928 if (!SWIG_IsOK(ecode2)) {
44929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44930 }
44931 arg2 = static_cast< unsigned int >(val2);
44932 {
44933 PyThreadState* __tstate = wxPyBeginAllowThreads();
44934 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44935 wxPyEndAllowThreads(__tstate);
44936 if (PyErr_Occurred()) SWIG_fail;
44937 }
44938 {
44939 #if wxUSE_UNICODE
44940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44941 #else
44942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44943 #endif
44944 }
44945 return resultobj;
44946 fail:
44947 return NULL;
44948 }
44949
44950
44951 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44952 PyObject *resultobj = 0;
44953 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44954 wxArrayString result;
44955 void *argp1 = 0 ;
44956 int res1 = 0 ;
44957 PyObject *swig_obj[1] ;
44958
44959 if (!args) SWIG_fail;
44960 swig_obj[0] = args;
44961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44962 if (!SWIG_IsOK(res1)) {
44963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44964 }
44965 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44966 {
44967 PyThreadState* __tstate = wxPyBeginAllowThreads();
44968 result = ((wxItemContainer const *)arg1)->GetStrings();
44969 wxPyEndAllowThreads(__tstate);
44970 if (PyErr_Occurred()) SWIG_fail;
44971 }
44972 {
44973 resultobj = wxArrayString2PyList_helper(result);
44974 }
44975 return resultobj;
44976 fail:
44977 return NULL;
44978 }
44979
44980
44981 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44982 PyObject *resultobj = 0;
44983 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44984 unsigned int arg2 ;
44985 wxString *arg3 = 0 ;
44986 void *argp1 = 0 ;
44987 int res1 = 0 ;
44988 unsigned int val2 ;
44989 int ecode2 = 0 ;
44990 bool temp3 = false ;
44991 PyObject * obj0 = 0 ;
44992 PyObject * obj1 = 0 ;
44993 PyObject * obj2 = 0 ;
44994 char * kwnames[] = {
44995 (char *) "self",(char *) "n",(char *) "s", NULL
44996 };
44997
44998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45000 if (!SWIG_IsOK(res1)) {
45001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45002 }
45003 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45004 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45005 if (!SWIG_IsOK(ecode2)) {
45006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45007 }
45008 arg2 = static_cast< unsigned int >(val2);
45009 {
45010 arg3 = wxString_in_helper(obj2);
45011 if (arg3 == NULL) SWIG_fail;
45012 temp3 = true;
45013 }
45014 {
45015 PyThreadState* __tstate = wxPyBeginAllowThreads();
45016 (arg1)->SetString(arg2,(wxString const &)*arg3);
45017 wxPyEndAllowThreads(__tstate);
45018 if (PyErr_Occurred()) SWIG_fail;
45019 }
45020 resultobj = SWIG_Py_Void();
45021 {
45022 if (temp3)
45023 delete arg3;
45024 }
45025 return resultobj;
45026 fail:
45027 {
45028 if (temp3)
45029 delete arg3;
45030 }
45031 return NULL;
45032 }
45033
45034
45035 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45036 PyObject *resultobj = 0;
45037 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45038 wxString *arg2 = 0 ;
45039 int result;
45040 void *argp1 = 0 ;
45041 int res1 = 0 ;
45042 bool temp2 = false ;
45043 PyObject * obj0 = 0 ;
45044 PyObject * obj1 = 0 ;
45045 char * kwnames[] = {
45046 (char *) "self",(char *) "s", NULL
45047 };
45048
45049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45051 if (!SWIG_IsOK(res1)) {
45052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45053 }
45054 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45055 {
45056 arg2 = wxString_in_helper(obj1);
45057 if (arg2 == NULL) SWIG_fail;
45058 temp2 = true;
45059 }
45060 {
45061 PyThreadState* __tstate = wxPyBeginAllowThreads();
45062 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45063 wxPyEndAllowThreads(__tstate);
45064 if (PyErr_Occurred()) SWIG_fail;
45065 }
45066 resultobj = SWIG_From_int(static_cast< int >(result));
45067 {
45068 if (temp2)
45069 delete arg2;
45070 }
45071 return resultobj;
45072 fail:
45073 {
45074 if (temp2)
45075 delete arg2;
45076 }
45077 return NULL;
45078 }
45079
45080
45081 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45082 PyObject *resultobj = 0;
45083 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45084 int arg2 ;
45085 void *argp1 = 0 ;
45086 int res1 = 0 ;
45087 int val2 ;
45088 int ecode2 = 0 ;
45089 PyObject * obj0 = 0 ;
45090 PyObject * obj1 = 0 ;
45091 char * kwnames[] = {
45092 (char *) "self",(char *) "n", NULL
45093 };
45094
45095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45097 if (!SWIG_IsOK(res1)) {
45098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45099 }
45100 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45101 ecode2 = SWIG_AsVal_int(obj1, &val2);
45102 if (!SWIG_IsOK(ecode2)) {
45103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45104 }
45105 arg2 = static_cast< int >(val2);
45106 {
45107 PyThreadState* __tstate = wxPyBeginAllowThreads();
45108 (arg1)->SetSelection(arg2);
45109 wxPyEndAllowThreads(__tstate);
45110 if (PyErr_Occurred()) SWIG_fail;
45111 }
45112 resultobj = SWIG_Py_Void();
45113 return resultobj;
45114 fail:
45115 return NULL;
45116 }
45117
45118
45119 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45120 PyObject *resultobj = 0;
45121 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45122 int result;
45123 void *argp1 = 0 ;
45124 int res1 = 0 ;
45125 PyObject *swig_obj[1] ;
45126
45127 if (!args) SWIG_fail;
45128 swig_obj[0] = args;
45129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45130 if (!SWIG_IsOK(res1)) {
45131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45132 }
45133 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45134 {
45135 PyThreadState* __tstate = wxPyBeginAllowThreads();
45136 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45137 wxPyEndAllowThreads(__tstate);
45138 if (PyErr_Occurred()) SWIG_fail;
45139 }
45140 resultobj = SWIG_From_int(static_cast< int >(result));
45141 return resultobj;
45142 fail:
45143 return NULL;
45144 }
45145
45146
45147 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45148 PyObject *resultobj = 0;
45149 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45150 wxString *arg2 = 0 ;
45151 bool result;
45152 void *argp1 = 0 ;
45153 int res1 = 0 ;
45154 bool temp2 = false ;
45155 PyObject * obj0 = 0 ;
45156 PyObject * obj1 = 0 ;
45157 char * kwnames[] = {
45158 (char *) "self",(char *) "s", NULL
45159 };
45160
45161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45163 if (!SWIG_IsOK(res1)) {
45164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45165 }
45166 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45167 {
45168 arg2 = wxString_in_helper(obj1);
45169 if (arg2 == NULL) SWIG_fail;
45170 temp2 = true;
45171 }
45172 {
45173 PyThreadState* __tstate = wxPyBeginAllowThreads();
45174 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45175 wxPyEndAllowThreads(__tstate);
45176 if (PyErr_Occurred()) SWIG_fail;
45177 }
45178 {
45179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45180 }
45181 {
45182 if (temp2)
45183 delete arg2;
45184 }
45185 return resultobj;
45186 fail:
45187 {
45188 if (temp2)
45189 delete arg2;
45190 }
45191 return NULL;
45192 }
45193
45194
45195 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45196 PyObject *resultobj = 0;
45197 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45198 wxString result;
45199 void *argp1 = 0 ;
45200 int res1 = 0 ;
45201 PyObject *swig_obj[1] ;
45202
45203 if (!args) SWIG_fail;
45204 swig_obj[0] = args;
45205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45206 if (!SWIG_IsOK(res1)) {
45207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45208 }
45209 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45210 {
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 {
45217 #if wxUSE_UNICODE
45218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45219 #else
45220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45221 #endif
45222 }
45223 return resultobj;
45224 fail:
45225 return NULL;
45226 }
45227
45228
45229 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45230 PyObject *resultobj = 0;
45231 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45232 int arg2 ;
45233 void *argp1 = 0 ;
45234 int res1 = 0 ;
45235 int val2 ;
45236 int ecode2 = 0 ;
45237 PyObject * obj0 = 0 ;
45238 PyObject * obj1 = 0 ;
45239 char * kwnames[] = {
45240 (char *) "self",(char *) "n", NULL
45241 };
45242
45243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45245 if (!SWIG_IsOK(res1)) {
45246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45247 }
45248 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45249 ecode2 = SWIG_AsVal_int(obj1, &val2);
45250 if (!SWIG_IsOK(ecode2)) {
45251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45252 }
45253 arg2 = static_cast< int >(val2);
45254 {
45255 PyThreadState* __tstate = wxPyBeginAllowThreads();
45256 (arg1)->Select(arg2);
45257 wxPyEndAllowThreads(__tstate);
45258 if (PyErr_Occurred()) SWIG_fail;
45259 }
45260 resultobj = SWIG_Py_Void();
45261 return resultobj;
45262 fail:
45263 return NULL;
45264 }
45265
45266
45267 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45268 PyObject *obj;
45269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45270 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45271 return SWIG_Py_Void();
45272 }
45273
45274 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45275 PyObject *obj;
45276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45277 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45278 return SWIG_Py_Void();
45279 }
45280
45281 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45282 PyObject *resultobj = 0;
45283 wxSizerItem *result = 0 ;
45284
45285 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45286 {
45287 PyThreadState* __tstate = wxPyBeginAllowThreads();
45288 result = (wxSizerItem *)new wxSizerItem();
45289 wxPyEndAllowThreads(__tstate);
45290 if (PyErr_Occurred()) SWIG_fail;
45291 }
45292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45293 return resultobj;
45294 fail:
45295 return NULL;
45296 }
45297
45298
45299 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45300 PyObject *resultobj = 0;
45301 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45302 void *argp1 = 0 ;
45303 int res1 = 0 ;
45304 PyObject *swig_obj[1] ;
45305
45306 if (!args) SWIG_fail;
45307 swig_obj[0] = args;
45308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45309 if (!SWIG_IsOK(res1)) {
45310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45311 }
45312 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45313 {
45314 PyThreadState* __tstate = wxPyBeginAllowThreads();
45315 delete arg1;
45316
45317 wxPyEndAllowThreads(__tstate);
45318 if (PyErr_Occurred()) SWIG_fail;
45319 }
45320 resultobj = SWIG_Py_Void();
45321 return resultobj;
45322 fail:
45323 return NULL;
45324 }
45325
45326
45327 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45328 PyObject *resultobj = 0;
45329 wxWindow *arg1 = (wxWindow *) 0 ;
45330 int arg2 ;
45331 int arg3 ;
45332 int arg4 ;
45333 PyObject *arg5 = (PyObject *) NULL ;
45334 wxSizerItem *result = 0 ;
45335 void *argp1 = 0 ;
45336 int res1 = 0 ;
45337 int val2 ;
45338 int ecode2 = 0 ;
45339 int val3 ;
45340 int ecode3 = 0 ;
45341 int val4 ;
45342 int ecode4 = 0 ;
45343 PyObject * obj0 = 0 ;
45344 PyObject * obj1 = 0 ;
45345 PyObject * obj2 = 0 ;
45346 PyObject * obj3 = 0 ;
45347 PyObject * obj4 = 0 ;
45348 char * kwnames[] = {
45349 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45350 };
45351
45352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45354 if (!SWIG_IsOK(res1)) {
45355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45356 }
45357 arg1 = reinterpret_cast< wxWindow * >(argp1);
45358 ecode2 = SWIG_AsVal_int(obj1, &val2);
45359 if (!SWIG_IsOK(ecode2)) {
45360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45361 }
45362 arg2 = static_cast< int >(val2);
45363 ecode3 = SWIG_AsVal_int(obj2, &val3);
45364 if (!SWIG_IsOK(ecode3)) {
45365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45366 }
45367 arg3 = static_cast< int >(val3);
45368 ecode4 = SWIG_AsVal_int(obj3, &val4);
45369 if (!SWIG_IsOK(ecode4)) {
45370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45371 }
45372 arg4 = static_cast< int >(val4);
45373 if (obj4) {
45374 arg5 = obj4;
45375 }
45376 {
45377 PyThreadState* __tstate = wxPyBeginAllowThreads();
45378 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45379 wxPyEndAllowThreads(__tstate);
45380 if (PyErr_Occurred()) SWIG_fail;
45381 }
45382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45383 return resultobj;
45384 fail:
45385 return NULL;
45386 }
45387
45388
45389 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45390 PyObject *resultobj = 0;
45391 int arg1 ;
45392 int arg2 ;
45393 int arg3 ;
45394 int arg4 ;
45395 int arg5 ;
45396 PyObject *arg6 = (PyObject *) NULL ;
45397 wxSizerItem *result = 0 ;
45398 int val1 ;
45399 int ecode1 = 0 ;
45400 int val2 ;
45401 int ecode2 = 0 ;
45402 int val3 ;
45403 int ecode3 = 0 ;
45404 int val4 ;
45405 int ecode4 = 0 ;
45406 int val5 ;
45407 int ecode5 = 0 ;
45408 PyObject * obj0 = 0 ;
45409 PyObject * obj1 = 0 ;
45410 PyObject * obj2 = 0 ;
45411 PyObject * obj3 = 0 ;
45412 PyObject * obj4 = 0 ;
45413 PyObject * obj5 = 0 ;
45414 char * kwnames[] = {
45415 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45416 };
45417
45418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45419 ecode1 = SWIG_AsVal_int(obj0, &val1);
45420 if (!SWIG_IsOK(ecode1)) {
45421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45422 }
45423 arg1 = static_cast< int >(val1);
45424 ecode2 = SWIG_AsVal_int(obj1, &val2);
45425 if (!SWIG_IsOK(ecode2)) {
45426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45427 }
45428 arg2 = static_cast< int >(val2);
45429 ecode3 = SWIG_AsVal_int(obj2, &val3);
45430 if (!SWIG_IsOK(ecode3)) {
45431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45432 }
45433 arg3 = static_cast< int >(val3);
45434 ecode4 = SWIG_AsVal_int(obj3, &val4);
45435 if (!SWIG_IsOK(ecode4)) {
45436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45437 }
45438 arg4 = static_cast< int >(val4);
45439 ecode5 = SWIG_AsVal_int(obj4, &val5);
45440 if (!SWIG_IsOK(ecode5)) {
45441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45442 }
45443 arg5 = static_cast< int >(val5);
45444 if (obj5) {
45445 arg6 = obj5;
45446 }
45447 {
45448 PyThreadState* __tstate = wxPyBeginAllowThreads();
45449 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45450 wxPyEndAllowThreads(__tstate);
45451 if (PyErr_Occurred()) SWIG_fail;
45452 }
45453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45454 return resultobj;
45455 fail:
45456 return NULL;
45457 }
45458
45459
45460 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45461 PyObject *resultobj = 0;
45462 wxSizer *arg1 = (wxSizer *) 0 ;
45463 int arg2 ;
45464 int arg3 ;
45465 int arg4 ;
45466 PyObject *arg5 = (PyObject *) NULL ;
45467 wxSizerItem *result = 0 ;
45468 int res1 = 0 ;
45469 int val2 ;
45470 int ecode2 = 0 ;
45471 int val3 ;
45472 int ecode3 = 0 ;
45473 int val4 ;
45474 int ecode4 = 0 ;
45475 PyObject * obj0 = 0 ;
45476 PyObject * obj1 = 0 ;
45477 PyObject * obj2 = 0 ;
45478 PyObject * obj3 = 0 ;
45479 PyObject * obj4 = 0 ;
45480 char * kwnames[] = {
45481 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45482 };
45483
45484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45485 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45486 if (!SWIG_IsOK(res1)) {
45487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45488 }
45489 ecode2 = SWIG_AsVal_int(obj1, &val2);
45490 if (!SWIG_IsOK(ecode2)) {
45491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45492 }
45493 arg2 = static_cast< int >(val2);
45494 ecode3 = SWIG_AsVal_int(obj2, &val3);
45495 if (!SWIG_IsOK(ecode3)) {
45496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45497 }
45498 arg3 = static_cast< int >(val3);
45499 ecode4 = SWIG_AsVal_int(obj3, &val4);
45500 if (!SWIG_IsOK(ecode4)) {
45501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45502 }
45503 arg4 = static_cast< int >(val4);
45504 if (obj4) {
45505 arg5 = obj4;
45506 }
45507 {
45508 PyThreadState* __tstate = wxPyBeginAllowThreads();
45509 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45510 wxPyEndAllowThreads(__tstate);
45511 if (PyErr_Occurred()) SWIG_fail;
45512 }
45513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45514 return resultobj;
45515 fail:
45516 return NULL;
45517 }
45518
45519
45520 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45521 PyObject *resultobj = 0;
45522 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45523 void *argp1 = 0 ;
45524 int res1 = 0 ;
45525 PyObject *swig_obj[1] ;
45526
45527 if (!args) SWIG_fail;
45528 swig_obj[0] = args;
45529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45530 if (!SWIG_IsOK(res1)) {
45531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45532 }
45533 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45534 {
45535 PyThreadState* __tstate = wxPyBeginAllowThreads();
45536 (arg1)->DeleteWindows();
45537 wxPyEndAllowThreads(__tstate);
45538 if (PyErr_Occurred()) SWIG_fail;
45539 }
45540 resultobj = SWIG_Py_Void();
45541 return resultobj;
45542 fail:
45543 return NULL;
45544 }
45545
45546
45547 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45548 PyObject *resultobj = 0;
45549 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45550 void *argp1 = 0 ;
45551 int res1 = 0 ;
45552 PyObject *swig_obj[1] ;
45553
45554 if (!args) SWIG_fail;
45555 swig_obj[0] = args;
45556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45557 if (!SWIG_IsOK(res1)) {
45558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45559 }
45560 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45561 {
45562 PyThreadState* __tstate = wxPyBeginAllowThreads();
45563 (arg1)->DetachSizer();
45564 wxPyEndAllowThreads(__tstate);
45565 if (PyErr_Occurred()) SWIG_fail;
45566 }
45567 resultobj = SWIG_Py_Void();
45568 return resultobj;
45569 fail:
45570 return NULL;
45571 }
45572
45573
45574 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45575 PyObject *resultobj = 0;
45576 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45577 wxSize result;
45578 void *argp1 = 0 ;
45579 int res1 = 0 ;
45580 PyObject *swig_obj[1] ;
45581
45582 if (!args) SWIG_fail;
45583 swig_obj[0] = args;
45584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45585 if (!SWIG_IsOK(res1)) {
45586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45587 }
45588 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45589 {
45590 PyThreadState* __tstate = wxPyBeginAllowThreads();
45591 result = (arg1)->GetSize();
45592 wxPyEndAllowThreads(__tstate);
45593 if (PyErr_Occurred()) SWIG_fail;
45594 }
45595 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45596 return resultobj;
45597 fail:
45598 return NULL;
45599 }
45600
45601
45602 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45603 PyObject *resultobj = 0;
45604 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45605 wxSize result;
45606 void *argp1 = 0 ;
45607 int res1 = 0 ;
45608 PyObject *swig_obj[1] ;
45609
45610 if (!args) SWIG_fail;
45611 swig_obj[0] = args;
45612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45613 if (!SWIG_IsOK(res1)) {
45614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45615 }
45616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45617 {
45618 PyThreadState* __tstate = wxPyBeginAllowThreads();
45619 result = (arg1)->CalcMin();
45620 wxPyEndAllowThreads(__tstate);
45621 if (PyErr_Occurred()) SWIG_fail;
45622 }
45623 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45624 return resultobj;
45625 fail:
45626 return NULL;
45627 }
45628
45629
45630 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45631 PyObject *resultobj = 0;
45632 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45633 wxPoint *arg2 = 0 ;
45634 wxSize *arg3 = 0 ;
45635 void *argp1 = 0 ;
45636 int res1 = 0 ;
45637 wxPoint temp2 ;
45638 wxSize temp3 ;
45639 PyObject * obj0 = 0 ;
45640 PyObject * obj1 = 0 ;
45641 PyObject * obj2 = 0 ;
45642 char * kwnames[] = {
45643 (char *) "self",(char *) "pos",(char *) "size", NULL
45644 };
45645
45646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45648 if (!SWIG_IsOK(res1)) {
45649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45650 }
45651 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45652 {
45653 arg2 = &temp2;
45654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45655 }
45656 {
45657 arg3 = &temp3;
45658 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45659 }
45660 {
45661 PyThreadState* __tstate = wxPyBeginAllowThreads();
45662 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45663 wxPyEndAllowThreads(__tstate);
45664 if (PyErr_Occurred()) SWIG_fail;
45665 }
45666 resultobj = SWIG_Py_Void();
45667 return resultobj;
45668 fail:
45669 return NULL;
45670 }
45671
45672
45673 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45674 PyObject *resultobj = 0;
45675 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45676 wxSize result;
45677 void *argp1 = 0 ;
45678 int res1 = 0 ;
45679 PyObject *swig_obj[1] ;
45680
45681 if (!args) SWIG_fail;
45682 swig_obj[0] = args;
45683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45684 if (!SWIG_IsOK(res1)) {
45685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45686 }
45687 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45688 {
45689 PyThreadState* __tstate = wxPyBeginAllowThreads();
45690 result = (arg1)->GetMinSize();
45691 wxPyEndAllowThreads(__tstate);
45692 if (PyErr_Occurred()) SWIG_fail;
45693 }
45694 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45695 return resultobj;
45696 fail:
45697 return NULL;
45698 }
45699
45700
45701 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45702 PyObject *resultobj = 0;
45703 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45704 wxSize result;
45705 void *argp1 = 0 ;
45706 int res1 = 0 ;
45707 PyObject *swig_obj[1] ;
45708
45709 if (!args) SWIG_fail;
45710 swig_obj[0] = args;
45711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45712 if (!SWIG_IsOK(res1)) {
45713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45714 }
45715 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45716 {
45717 PyThreadState* __tstate = wxPyBeginAllowThreads();
45718 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45719 wxPyEndAllowThreads(__tstate);
45720 if (PyErr_Occurred()) SWIG_fail;
45721 }
45722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45723 return resultobj;
45724 fail:
45725 return NULL;
45726 }
45727
45728
45729 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45730 PyObject *resultobj = 0;
45731 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45732 int arg2 ;
45733 int arg3 ;
45734 void *argp1 = 0 ;
45735 int res1 = 0 ;
45736 int val2 ;
45737 int ecode2 = 0 ;
45738 int val3 ;
45739 int ecode3 = 0 ;
45740 PyObject * obj0 = 0 ;
45741 PyObject * obj1 = 0 ;
45742 PyObject * obj2 = 0 ;
45743 char * kwnames[] = {
45744 (char *) "self",(char *) "x",(char *) "y", NULL
45745 };
45746
45747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45749 if (!SWIG_IsOK(res1)) {
45750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45751 }
45752 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45753 ecode2 = SWIG_AsVal_int(obj1, &val2);
45754 if (!SWIG_IsOK(ecode2)) {
45755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45756 }
45757 arg2 = static_cast< int >(val2);
45758 ecode3 = SWIG_AsVal_int(obj2, &val3);
45759 if (!SWIG_IsOK(ecode3)) {
45760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45761 }
45762 arg3 = static_cast< int >(val3);
45763 {
45764 PyThreadState* __tstate = wxPyBeginAllowThreads();
45765 (arg1)->SetInitSize(arg2,arg3);
45766 wxPyEndAllowThreads(__tstate);
45767 if (PyErr_Occurred()) SWIG_fail;
45768 }
45769 resultobj = SWIG_Py_Void();
45770 return resultobj;
45771 fail:
45772 return NULL;
45773 }
45774
45775
45776 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45777 PyObject *resultobj = 0;
45778 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45779 int arg2 ;
45780 int arg3 ;
45781 void *argp1 = 0 ;
45782 int res1 = 0 ;
45783 int val2 ;
45784 int ecode2 = 0 ;
45785 int val3 ;
45786 int ecode3 = 0 ;
45787 PyObject * obj0 = 0 ;
45788 PyObject * obj1 = 0 ;
45789 PyObject * obj2 = 0 ;
45790 char * kwnames[] = {
45791 (char *) "self",(char *) "width",(char *) "height", NULL
45792 };
45793
45794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45796 if (!SWIG_IsOK(res1)) {
45797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45798 }
45799 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45800 ecode2 = SWIG_AsVal_int(obj1, &val2);
45801 if (!SWIG_IsOK(ecode2)) {
45802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45803 }
45804 arg2 = static_cast< int >(val2);
45805 ecode3 = SWIG_AsVal_int(obj2, &val3);
45806 if (!SWIG_IsOK(ecode3)) {
45807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45808 }
45809 arg3 = static_cast< int >(val3);
45810 {
45811 PyThreadState* __tstate = wxPyBeginAllowThreads();
45812 (arg1)->SetRatio(arg2,arg3);
45813 wxPyEndAllowThreads(__tstate);
45814 if (PyErr_Occurred()) SWIG_fail;
45815 }
45816 resultobj = SWIG_Py_Void();
45817 return resultobj;
45818 fail:
45819 return NULL;
45820 }
45821
45822
45823 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45824 PyObject *resultobj = 0;
45825 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45826 wxSize *arg2 = 0 ;
45827 void *argp1 = 0 ;
45828 int res1 = 0 ;
45829 wxSize temp2 ;
45830 PyObject * obj0 = 0 ;
45831 PyObject * obj1 = 0 ;
45832 char * kwnames[] = {
45833 (char *) "self",(char *) "size", NULL
45834 };
45835
45836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45838 if (!SWIG_IsOK(res1)) {
45839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45840 }
45841 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45842 {
45843 arg2 = &temp2;
45844 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45845 }
45846 {
45847 PyThreadState* __tstate = wxPyBeginAllowThreads();
45848 (arg1)->SetRatio((wxSize const &)*arg2);
45849 wxPyEndAllowThreads(__tstate);
45850 if (PyErr_Occurred()) SWIG_fail;
45851 }
45852 resultobj = SWIG_Py_Void();
45853 return resultobj;
45854 fail:
45855 return NULL;
45856 }
45857
45858
45859 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45860 PyObject *resultobj = 0;
45861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45862 float arg2 ;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 float val2 ;
45866 int ecode2 = 0 ;
45867 PyObject * obj0 = 0 ;
45868 PyObject * obj1 = 0 ;
45869 char * kwnames[] = {
45870 (char *) "self",(char *) "ratio", NULL
45871 };
45872
45873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45875 if (!SWIG_IsOK(res1)) {
45876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45877 }
45878 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45879 ecode2 = SWIG_AsVal_float(obj1, &val2);
45880 if (!SWIG_IsOK(ecode2)) {
45881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45882 }
45883 arg2 = static_cast< float >(val2);
45884 {
45885 PyThreadState* __tstate = wxPyBeginAllowThreads();
45886 (arg1)->SetRatio(arg2);
45887 wxPyEndAllowThreads(__tstate);
45888 if (PyErr_Occurred()) SWIG_fail;
45889 }
45890 resultobj = SWIG_Py_Void();
45891 return resultobj;
45892 fail:
45893 return NULL;
45894 }
45895
45896
45897 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45898 PyObject *resultobj = 0;
45899 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45900 float result;
45901 void *argp1 = 0 ;
45902 int res1 = 0 ;
45903 PyObject *swig_obj[1] ;
45904
45905 if (!args) SWIG_fail;
45906 swig_obj[0] = args;
45907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45908 if (!SWIG_IsOK(res1)) {
45909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45910 }
45911 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45912 {
45913 PyThreadState* __tstate = wxPyBeginAllowThreads();
45914 result = (float)(arg1)->GetRatio();
45915 wxPyEndAllowThreads(__tstate);
45916 if (PyErr_Occurred()) SWIG_fail;
45917 }
45918 resultobj = SWIG_From_float(static_cast< float >(result));
45919 return resultobj;
45920 fail:
45921 return NULL;
45922 }
45923
45924
45925 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45926 PyObject *resultobj = 0;
45927 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45928 wxRect result;
45929 void *argp1 = 0 ;
45930 int res1 = 0 ;
45931 PyObject *swig_obj[1] ;
45932
45933 if (!args) SWIG_fail;
45934 swig_obj[0] = args;
45935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45936 if (!SWIG_IsOK(res1)) {
45937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45938 }
45939 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45940 {
45941 PyThreadState* __tstate = wxPyBeginAllowThreads();
45942 result = (arg1)->GetRect();
45943 wxPyEndAllowThreads(__tstate);
45944 if (PyErr_Occurred()) SWIG_fail;
45945 }
45946 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45947 return resultobj;
45948 fail:
45949 return NULL;
45950 }
45951
45952
45953 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45954 PyObject *resultobj = 0;
45955 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45956 bool result;
45957 void *argp1 = 0 ;
45958 int res1 = 0 ;
45959 PyObject *swig_obj[1] ;
45960
45961 if (!args) SWIG_fail;
45962 swig_obj[0] = args;
45963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45964 if (!SWIG_IsOK(res1)) {
45965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45966 }
45967 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45968 {
45969 PyThreadState* __tstate = wxPyBeginAllowThreads();
45970 result = (bool)(arg1)->IsWindow();
45971 wxPyEndAllowThreads(__tstate);
45972 if (PyErr_Occurred()) SWIG_fail;
45973 }
45974 {
45975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45976 }
45977 return resultobj;
45978 fail:
45979 return NULL;
45980 }
45981
45982
45983 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45984 PyObject *resultobj = 0;
45985 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45986 bool result;
45987 void *argp1 = 0 ;
45988 int res1 = 0 ;
45989 PyObject *swig_obj[1] ;
45990
45991 if (!args) SWIG_fail;
45992 swig_obj[0] = args;
45993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45994 if (!SWIG_IsOK(res1)) {
45995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45996 }
45997 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45998 {
45999 PyThreadState* __tstate = wxPyBeginAllowThreads();
46000 result = (bool)(arg1)->IsSizer();
46001 wxPyEndAllowThreads(__tstate);
46002 if (PyErr_Occurred()) SWIG_fail;
46003 }
46004 {
46005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46006 }
46007 return resultobj;
46008 fail:
46009 return NULL;
46010 }
46011
46012
46013 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46014 PyObject *resultobj = 0;
46015 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46016 bool result;
46017 void *argp1 = 0 ;
46018 int res1 = 0 ;
46019 PyObject *swig_obj[1] ;
46020
46021 if (!args) SWIG_fail;
46022 swig_obj[0] = args;
46023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46024 if (!SWIG_IsOK(res1)) {
46025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46026 }
46027 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46028 {
46029 PyThreadState* __tstate = wxPyBeginAllowThreads();
46030 result = (bool)(arg1)->IsSpacer();
46031 wxPyEndAllowThreads(__tstate);
46032 if (PyErr_Occurred()) SWIG_fail;
46033 }
46034 {
46035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46036 }
46037 return resultobj;
46038 fail:
46039 return NULL;
46040 }
46041
46042
46043 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46044 PyObject *resultobj = 0;
46045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46046 int arg2 ;
46047 void *argp1 = 0 ;
46048 int res1 = 0 ;
46049 int val2 ;
46050 int ecode2 = 0 ;
46051 PyObject * obj0 = 0 ;
46052 PyObject * obj1 = 0 ;
46053 char * kwnames[] = {
46054 (char *) "self",(char *) "proportion", NULL
46055 };
46056
46057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46059 if (!SWIG_IsOK(res1)) {
46060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46061 }
46062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46063 ecode2 = SWIG_AsVal_int(obj1, &val2);
46064 if (!SWIG_IsOK(ecode2)) {
46065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46066 }
46067 arg2 = static_cast< int >(val2);
46068 {
46069 PyThreadState* __tstate = wxPyBeginAllowThreads();
46070 (arg1)->SetProportion(arg2);
46071 wxPyEndAllowThreads(__tstate);
46072 if (PyErr_Occurred()) SWIG_fail;
46073 }
46074 resultobj = SWIG_Py_Void();
46075 return resultobj;
46076 fail:
46077 return NULL;
46078 }
46079
46080
46081 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46082 PyObject *resultobj = 0;
46083 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46084 int result;
46085 void *argp1 = 0 ;
46086 int res1 = 0 ;
46087 PyObject *swig_obj[1] ;
46088
46089 if (!args) SWIG_fail;
46090 swig_obj[0] = args;
46091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46092 if (!SWIG_IsOK(res1)) {
46093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46094 }
46095 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46096 {
46097 PyThreadState* __tstate = wxPyBeginAllowThreads();
46098 result = (int)(arg1)->GetProportion();
46099 wxPyEndAllowThreads(__tstate);
46100 if (PyErr_Occurred()) SWIG_fail;
46101 }
46102 resultobj = SWIG_From_int(static_cast< int >(result));
46103 return resultobj;
46104 fail:
46105 return NULL;
46106 }
46107
46108
46109 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46110 PyObject *resultobj = 0;
46111 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46112 int arg2 ;
46113 void *argp1 = 0 ;
46114 int res1 = 0 ;
46115 int val2 ;
46116 int ecode2 = 0 ;
46117 PyObject * obj0 = 0 ;
46118 PyObject * obj1 = 0 ;
46119 char * kwnames[] = {
46120 (char *) "self",(char *) "flag", NULL
46121 };
46122
46123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46125 if (!SWIG_IsOK(res1)) {
46126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46127 }
46128 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46129 ecode2 = SWIG_AsVal_int(obj1, &val2);
46130 if (!SWIG_IsOK(ecode2)) {
46131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46132 }
46133 arg2 = static_cast< int >(val2);
46134 {
46135 PyThreadState* __tstate = wxPyBeginAllowThreads();
46136 (arg1)->SetFlag(arg2);
46137 wxPyEndAllowThreads(__tstate);
46138 if (PyErr_Occurred()) SWIG_fail;
46139 }
46140 resultobj = SWIG_Py_Void();
46141 return resultobj;
46142 fail:
46143 return NULL;
46144 }
46145
46146
46147 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46148 PyObject *resultobj = 0;
46149 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46150 int result;
46151 void *argp1 = 0 ;
46152 int res1 = 0 ;
46153 PyObject *swig_obj[1] ;
46154
46155 if (!args) SWIG_fail;
46156 swig_obj[0] = args;
46157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46158 if (!SWIG_IsOK(res1)) {
46159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46160 }
46161 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46162 {
46163 PyThreadState* __tstate = wxPyBeginAllowThreads();
46164 result = (int)(arg1)->GetFlag();
46165 wxPyEndAllowThreads(__tstate);
46166 if (PyErr_Occurred()) SWIG_fail;
46167 }
46168 resultobj = SWIG_From_int(static_cast< int >(result));
46169 return resultobj;
46170 fail:
46171 return NULL;
46172 }
46173
46174
46175 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46176 PyObject *resultobj = 0;
46177 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46178 int arg2 ;
46179 void *argp1 = 0 ;
46180 int res1 = 0 ;
46181 int val2 ;
46182 int ecode2 = 0 ;
46183 PyObject * obj0 = 0 ;
46184 PyObject * obj1 = 0 ;
46185 char * kwnames[] = {
46186 (char *) "self",(char *) "border", NULL
46187 };
46188
46189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46191 if (!SWIG_IsOK(res1)) {
46192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46193 }
46194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46195 ecode2 = SWIG_AsVal_int(obj1, &val2);
46196 if (!SWIG_IsOK(ecode2)) {
46197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46198 }
46199 arg2 = static_cast< int >(val2);
46200 {
46201 PyThreadState* __tstate = wxPyBeginAllowThreads();
46202 (arg1)->SetBorder(arg2);
46203 wxPyEndAllowThreads(__tstate);
46204 if (PyErr_Occurred()) SWIG_fail;
46205 }
46206 resultobj = SWIG_Py_Void();
46207 return resultobj;
46208 fail:
46209 return NULL;
46210 }
46211
46212
46213 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46214 PyObject *resultobj = 0;
46215 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46216 int result;
46217 void *argp1 = 0 ;
46218 int res1 = 0 ;
46219 PyObject *swig_obj[1] ;
46220
46221 if (!args) SWIG_fail;
46222 swig_obj[0] = args;
46223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46224 if (!SWIG_IsOK(res1)) {
46225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46226 }
46227 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46228 {
46229 PyThreadState* __tstate = wxPyBeginAllowThreads();
46230 result = (int)(arg1)->GetBorder();
46231 wxPyEndAllowThreads(__tstate);
46232 if (PyErr_Occurred()) SWIG_fail;
46233 }
46234 resultobj = SWIG_From_int(static_cast< int >(result));
46235 return resultobj;
46236 fail:
46237 return NULL;
46238 }
46239
46240
46241 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46242 PyObject *resultobj = 0;
46243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46244 wxWindow *result = 0 ;
46245 void *argp1 = 0 ;
46246 int res1 = 0 ;
46247 PyObject *swig_obj[1] ;
46248
46249 if (!args) SWIG_fail;
46250 swig_obj[0] = args;
46251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46252 if (!SWIG_IsOK(res1)) {
46253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46254 }
46255 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46256 {
46257 PyThreadState* __tstate = wxPyBeginAllowThreads();
46258 result = (wxWindow *)(arg1)->GetWindow();
46259 wxPyEndAllowThreads(__tstate);
46260 if (PyErr_Occurred()) SWIG_fail;
46261 }
46262 {
46263 resultobj = wxPyMake_wxObject(result, 0);
46264 }
46265 return resultobj;
46266 fail:
46267 return NULL;
46268 }
46269
46270
46271 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46272 PyObject *resultobj = 0;
46273 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46274 wxWindow *arg2 = (wxWindow *) 0 ;
46275 void *argp1 = 0 ;
46276 int res1 = 0 ;
46277 void *argp2 = 0 ;
46278 int res2 = 0 ;
46279 PyObject * obj0 = 0 ;
46280 PyObject * obj1 = 0 ;
46281 char * kwnames[] = {
46282 (char *) "self",(char *) "window", NULL
46283 };
46284
46285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46287 if (!SWIG_IsOK(res1)) {
46288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46289 }
46290 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46292 if (!SWIG_IsOK(res2)) {
46293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46294 }
46295 arg2 = reinterpret_cast< wxWindow * >(argp2);
46296 {
46297 PyThreadState* __tstate = wxPyBeginAllowThreads();
46298 (arg1)->SetWindow(arg2);
46299 wxPyEndAllowThreads(__tstate);
46300 if (PyErr_Occurred()) SWIG_fail;
46301 }
46302 resultobj = SWIG_Py_Void();
46303 return resultobj;
46304 fail:
46305 return NULL;
46306 }
46307
46308
46309 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46310 PyObject *resultobj = 0;
46311 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46312 wxSizer *result = 0 ;
46313 void *argp1 = 0 ;
46314 int res1 = 0 ;
46315 PyObject *swig_obj[1] ;
46316
46317 if (!args) SWIG_fail;
46318 swig_obj[0] = args;
46319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46320 if (!SWIG_IsOK(res1)) {
46321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46322 }
46323 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46324 {
46325 PyThreadState* __tstate = wxPyBeginAllowThreads();
46326 result = (wxSizer *)(arg1)->GetSizer();
46327 wxPyEndAllowThreads(__tstate);
46328 if (PyErr_Occurred()) SWIG_fail;
46329 }
46330 {
46331 resultobj = wxPyMake_wxObject(result, (bool)0);
46332 }
46333 return resultobj;
46334 fail:
46335 return NULL;
46336 }
46337
46338
46339 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46340 PyObject *resultobj = 0;
46341 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46342 wxSizer *arg2 = (wxSizer *) 0 ;
46343 void *argp1 = 0 ;
46344 int res1 = 0 ;
46345 int res2 = 0 ;
46346 PyObject * obj0 = 0 ;
46347 PyObject * obj1 = 0 ;
46348 char * kwnames[] = {
46349 (char *) "self",(char *) "sizer", NULL
46350 };
46351
46352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46354 if (!SWIG_IsOK(res1)) {
46355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46356 }
46357 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46358 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46359 if (!SWIG_IsOK(res2)) {
46360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46361 }
46362 {
46363 PyThreadState* __tstate = wxPyBeginAllowThreads();
46364 (arg1)->SetSizer(arg2);
46365 wxPyEndAllowThreads(__tstate);
46366 if (PyErr_Occurred()) SWIG_fail;
46367 }
46368 resultobj = SWIG_Py_Void();
46369 return resultobj;
46370 fail:
46371 return NULL;
46372 }
46373
46374
46375 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46376 PyObject *resultobj = 0;
46377 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46378 wxSize *result = 0 ;
46379 void *argp1 = 0 ;
46380 int res1 = 0 ;
46381 PyObject *swig_obj[1] ;
46382
46383 if (!args) SWIG_fail;
46384 swig_obj[0] = args;
46385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46386 if (!SWIG_IsOK(res1)) {
46387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46388 }
46389 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46390 {
46391 PyThreadState* __tstate = wxPyBeginAllowThreads();
46392 {
46393 wxSize const &_result_ref = (arg1)->GetSpacer();
46394 result = (wxSize *) &_result_ref;
46395 }
46396 wxPyEndAllowThreads(__tstate);
46397 if (PyErr_Occurred()) SWIG_fail;
46398 }
46399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46400 return resultobj;
46401 fail:
46402 return NULL;
46403 }
46404
46405
46406 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46407 PyObject *resultobj = 0;
46408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46409 wxSize *arg2 = 0 ;
46410 void *argp1 = 0 ;
46411 int res1 = 0 ;
46412 wxSize temp2 ;
46413 PyObject * obj0 = 0 ;
46414 PyObject * obj1 = 0 ;
46415 char * kwnames[] = {
46416 (char *) "self",(char *) "size", NULL
46417 };
46418
46419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46421 if (!SWIG_IsOK(res1)) {
46422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46423 }
46424 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46425 {
46426 arg2 = &temp2;
46427 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46428 }
46429 {
46430 PyThreadState* __tstate = wxPyBeginAllowThreads();
46431 (arg1)->SetSpacer((wxSize const &)*arg2);
46432 wxPyEndAllowThreads(__tstate);
46433 if (PyErr_Occurred()) SWIG_fail;
46434 }
46435 resultobj = SWIG_Py_Void();
46436 return resultobj;
46437 fail:
46438 return NULL;
46439 }
46440
46441
46442 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46443 PyObject *resultobj = 0;
46444 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46445 bool arg2 ;
46446 void *argp1 = 0 ;
46447 int res1 = 0 ;
46448 bool val2 ;
46449 int ecode2 = 0 ;
46450 PyObject * obj0 = 0 ;
46451 PyObject * obj1 = 0 ;
46452 char * kwnames[] = {
46453 (char *) "self",(char *) "show", NULL
46454 };
46455
46456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46458 if (!SWIG_IsOK(res1)) {
46459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46460 }
46461 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46462 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46463 if (!SWIG_IsOK(ecode2)) {
46464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46465 }
46466 arg2 = static_cast< bool >(val2);
46467 {
46468 PyThreadState* __tstate = wxPyBeginAllowThreads();
46469 (arg1)->Show(arg2);
46470 wxPyEndAllowThreads(__tstate);
46471 if (PyErr_Occurred()) SWIG_fail;
46472 }
46473 resultobj = SWIG_Py_Void();
46474 return resultobj;
46475 fail:
46476 return NULL;
46477 }
46478
46479
46480 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46481 PyObject *resultobj = 0;
46482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46483 bool result;
46484 void *argp1 = 0 ;
46485 int res1 = 0 ;
46486 PyObject *swig_obj[1] ;
46487
46488 if (!args) SWIG_fail;
46489 swig_obj[0] = args;
46490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46491 if (!SWIG_IsOK(res1)) {
46492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46493 }
46494 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46495 {
46496 PyThreadState* __tstate = wxPyBeginAllowThreads();
46497 result = (bool)(arg1)->IsShown();
46498 wxPyEndAllowThreads(__tstate);
46499 if (PyErr_Occurred()) SWIG_fail;
46500 }
46501 {
46502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46503 }
46504 return resultobj;
46505 fail:
46506 return NULL;
46507 }
46508
46509
46510 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46511 PyObject *resultobj = 0;
46512 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46513 wxPoint result;
46514 void *argp1 = 0 ;
46515 int res1 = 0 ;
46516 PyObject *swig_obj[1] ;
46517
46518 if (!args) SWIG_fail;
46519 swig_obj[0] = args;
46520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46521 if (!SWIG_IsOK(res1)) {
46522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46523 }
46524 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46525 {
46526 PyThreadState* __tstate = wxPyBeginAllowThreads();
46527 result = (arg1)->GetPosition();
46528 wxPyEndAllowThreads(__tstate);
46529 if (PyErr_Occurred()) SWIG_fail;
46530 }
46531 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46532 return resultobj;
46533 fail:
46534 return NULL;
46535 }
46536
46537
46538 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46539 PyObject *resultobj = 0;
46540 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46541 PyObject *result = 0 ;
46542 void *argp1 = 0 ;
46543 int res1 = 0 ;
46544 PyObject *swig_obj[1] ;
46545
46546 if (!args) SWIG_fail;
46547 swig_obj[0] = args;
46548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46549 if (!SWIG_IsOK(res1)) {
46550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46551 }
46552 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46553 {
46554 PyThreadState* __tstate = wxPyBeginAllowThreads();
46555 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46556 wxPyEndAllowThreads(__tstate);
46557 if (PyErr_Occurred()) SWIG_fail;
46558 }
46559 resultobj = result;
46560 return resultobj;
46561 fail:
46562 return NULL;
46563 }
46564
46565
46566 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46567 PyObject *resultobj = 0;
46568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46569 PyObject *arg2 = (PyObject *) 0 ;
46570 void *argp1 = 0 ;
46571 int res1 = 0 ;
46572 PyObject * obj0 = 0 ;
46573 PyObject * obj1 = 0 ;
46574 char * kwnames[] = {
46575 (char *) "self",(char *) "userData", NULL
46576 };
46577
46578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46580 if (!SWIG_IsOK(res1)) {
46581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46582 }
46583 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46584 arg2 = obj1;
46585 {
46586 PyThreadState* __tstate = wxPyBeginAllowThreads();
46587 wxSizerItem_SetUserData(arg1,arg2);
46588 wxPyEndAllowThreads(__tstate);
46589 if (PyErr_Occurred()) SWIG_fail;
46590 }
46591 resultobj = SWIG_Py_Void();
46592 return resultobj;
46593 fail:
46594 return NULL;
46595 }
46596
46597
46598 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46599 PyObject *obj;
46600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46601 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46602 return SWIG_Py_Void();
46603 }
46604
46605 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46606 return SWIG_Python_InitShadowInstance(args);
46607 }
46608
46609 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46610 PyObject *resultobj = 0;
46611 wxSizer *arg1 = (wxSizer *) 0 ;
46612 void *argp1 = 0 ;
46613 int res1 = 0 ;
46614 PyObject *swig_obj[1] ;
46615
46616 if (!args) SWIG_fail;
46617 swig_obj[0] = args;
46618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46619 if (!SWIG_IsOK(res1)) {
46620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46621 }
46622 arg1 = reinterpret_cast< wxSizer * >(argp1);
46623 {
46624 PyThreadState* __tstate = wxPyBeginAllowThreads();
46625 delete arg1;
46626
46627 wxPyEndAllowThreads(__tstate);
46628 if (PyErr_Occurred()) SWIG_fail;
46629 }
46630 resultobj = SWIG_Py_Void();
46631 return resultobj;
46632 fail:
46633 return NULL;
46634 }
46635
46636
46637 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46638 PyObject *resultobj = 0;
46639 wxSizer *arg1 = (wxSizer *) 0 ;
46640 PyObject *arg2 = (PyObject *) 0 ;
46641 void *argp1 = 0 ;
46642 int res1 = 0 ;
46643 PyObject * obj0 = 0 ;
46644 PyObject * obj1 = 0 ;
46645 char * kwnames[] = {
46646 (char *) "self",(char *) "_self", NULL
46647 };
46648
46649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46651 if (!SWIG_IsOK(res1)) {
46652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46653 }
46654 arg1 = reinterpret_cast< wxSizer * >(argp1);
46655 arg2 = obj1;
46656 {
46657 PyThreadState* __tstate = wxPyBeginAllowThreads();
46658 wxSizer__setOORInfo(arg1,arg2);
46659 wxPyEndAllowThreads(__tstate);
46660 if (PyErr_Occurred()) SWIG_fail;
46661 }
46662 resultobj = SWIG_Py_Void();
46663 return resultobj;
46664 fail:
46665 return NULL;
46666 }
46667
46668
46669 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46670 PyObject *resultobj = 0;
46671 wxSizer *arg1 = (wxSizer *) 0 ;
46672 PyObject *arg2 = (PyObject *) 0 ;
46673 int arg3 = (int) 0 ;
46674 int arg4 = (int) 0 ;
46675 int arg5 = (int) 0 ;
46676 PyObject *arg6 = (PyObject *) NULL ;
46677 wxSizerItem *result = 0 ;
46678 void *argp1 = 0 ;
46679 int res1 = 0 ;
46680 int val3 ;
46681 int ecode3 = 0 ;
46682 int val4 ;
46683 int ecode4 = 0 ;
46684 int val5 ;
46685 int ecode5 = 0 ;
46686 PyObject * obj0 = 0 ;
46687 PyObject * obj1 = 0 ;
46688 PyObject * obj2 = 0 ;
46689 PyObject * obj3 = 0 ;
46690 PyObject * obj4 = 0 ;
46691 PyObject * obj5 = 0 ;
46692 char * kwnames[] = {
46693 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46694 };
46695
46696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46698 if (!SWIG_IsOK(res1)) {
46699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46700 }
46701 arg1 = reinterpret_cast< wxSizer * >(argp1);
46702 arg2 = obj1;
46703 if (obj2) {
46704 ecode3 = SWIG_AsVal_int(obj2, &val3);
46705 if (!SWIG_IsOK(ecode3)) {
46706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46707 }
46708 arg3 = static_cast< int >(val3);
46709 }
46710 if (obj3) {
46711 ecode4 = SWIG_AsVal_int(obj3, &val4);
46712 if (!SWIG_IsOK(ecode4)) {
46713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46714 }
46715 arg4 = static_cast< int >(val4);
46716 }
46717 if (obj4) {
46718 ecode5 = SWIG_AsVal_int(obj4, &val5);
46719 if (!SWIG_IsOK(ecode5)) {
46720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46721 }
46722 arg5 = static_cast< int >(val5);
46723 }
46724 if (obj5) {
46725 arg6 = obj5;
46726 }
46727 {
46728 PyThreadState* __tstate = wxPyBeginAllowThreads();
46729 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46730 wxPyEndAllowThreads(__tstate);
46731 if (PyErr_Occurred()) SWIG_fail;
46732 }
46733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46734 return resultobj;
46735 fail:
46736 return NULL;
46737 }
46738
46739
46740 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46741 PyObject *resultobj = 0;
46742 wxSizer *arg1 = (wxSizer *) 0 ;
46743 int arg2 ;
46744 PyObject *arg3 = (PyObject *) 0 ;
46745 int arg4 = (int) 0 ;
46746 int arg5 = (int) 0 ;
46747 int arg6 = (int) 0 ;
46748 PyObject *arg7 = (PyObject *) NULL ;
46749 wxSizerItem *result = 0 ;
46750 void *argp1 = 0 ;
46751 int res1 = 0 ;
46752 int val2 ;
46753 int ecode2 = 0 ;
46754 int val4 ;
46755 int ecode4 = 0 ;
46756 int val5 ;
46757 int ecode5 = 0 ;
46758 int val6 ;
46759 int ecode6 = 0 ;
46760 PyObject * obj0 = 0 ;
46761 PyObject * obj1 = 0 ;
46762 PyObject * obj2 = 0 ;
46763 PyObject * obj3 = 0 ;
46764 PyObject * obj4 = 0 ;
46765 PyObject * obj5 = 0 ;
46766 PyObject * obj6 = 0 ;
46767 char * kwnames[] = {
46768 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46769 };
46770
46771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46773 if (!SWIG_IsOK(res1)) {
46774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46775 }
46776 arg1 = reinterpret_cast< wxSizer * >(argp1);
46777 ecode2 = SWIG_AsVal_int(obj1, &val2);
46778 if (!SWIG_IsOK(ecode2)) {
46779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46780 }
46781 arg2 = static_cast< int >(val2);
46782 arg3 = obj2;
46783 if (obj3) {
46784 ecode4 = SWIG_AsVal_int(obj3, &val4);
46785 if (!SWIG_IsOK(ecode4)) {
46786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46787 }
46788 arg4 = static_cast< int >(val4);
46789 }
46790 if (obj4) {
46791 ecode5 = SWIG_AsVal_int(obj4, &val5);
46792 if (!SWIG_IsOK(ecode5)) {
46793 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46794 }
46795 arg5 = static_cast< int >(val5);
46796 }
46797 if (obj5) {
46798 ecode6 = SWIG_AsVal_int(obj5, &val6);
46799 if (!SWIG_IsOK(ecode6)) {
46800 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46801 }
46802 arg6 = static_cast< int >(val6);
46803 }
46804 if (obj6) {
46805 arg7 = obj6;
46806 }
46807 {
46808 PyThreadState* __tstate = wxPyBeginAllowThreads();
46809 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46810 wxPyEndAllowThreads(__tstate);
46811 if (PyErr_Occurred()) SWIG_fail;
46812 }
46813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46814 return resultobj;
46815 fail:
46816 return NULL;
46817 }
46818
46819
46820 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46821 PyObject *resultobj = 0;
46822 wxSizer *arg1 = (wxSizer *) 0 ;
46823 PyObject *arg2 = (PyObject *) 0 ;
46824 int arg3 = (int) 0 ;
46825 int arg4 = (int) 0 ;
46826 int arg5 = (int) 0 ;
46827 PyObject *arg6 = (PyObject *) NULL ;
46828 wxSizerItem *result = 0 ;
46829 void *argp1 = 0 ;
46830 int res1 = 0 ;
46831 int val3 ;
46832 int ecode3 = 0 ;
46833 int val4 ;
46834 int ecode4 = 0 ;
46835 int val5 ;
46836 int ecode5 = 0 ;
46837 PyObject * obj0 = 0 ;
46838 PyObject * obj1 = 0 ;
46839 PyObject * obj2 = 0 ;
46840 PyObject * obj3 = 0 ;
46841 PyObject * obj4 = 0 ;
46842 PyObject * obj5 = 0 ;
46843 char * kwnames[] = {
46844 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46845 };
46846
46847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46849 if (!SWIG_IsOK(res1)) {
46850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46851 }
46852 arg1 = reinterpret_cast< wxSizer * >(argp1);
46853 arg2 = obj1;
46854 if (obj2) {
46855 ecode3 = SWIG_AsVal_int(obj2, &val3);
46856 if (!SWIG_IsOK(ecode3)) {
46857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46858 }
46859 arg3 = static_cast< int >(val3);
46860 }
46861 if (obj3) {
46862 ecode4 = SWIG_AsVal_int(obj3, &val4);
46863 if (!SWIG_IsOK(ecode4)) {
46864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46865 }
46866 arg4 = static_cast< int >(val4);
46867 }
46868 if (obj4) {
46869 ecode5 = SWIG_AsVal_int(obj4, &val5);
46870 if (!SWIG_IsOK(ecode5)) {
46871 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46872 }
46873 arg5 = static_cast< int >(val5);
46874 }
46875 if (obj5) {
46876 arg6 = obj5;
46877 }
46878 {
46879 PyThreadState* __tstate = wxPyBeginAllowThreads();
46880 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46881 wxPyEndAllowThreads(__tstate);
46882 if (PyErr_Occurred()) SWIG_fail;
46883 }
46884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46885 return resultobj;
46886 fail:
46887 return NULL;
46888 }
46889
46890
46891 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46892 PyObject *resultobj = 0;
46893 wxSizer *arg1 = (wxSizer *) 0 ;
46894 PyObject *arg2 = (PyObject *) 0 ;
46895 bool result;
46896 void *argp1 = 0 ;
46897 int res1 = 0 ;
46898 PyObject * obj0 = 0 ;
46899 PyObject * obj1 = 0 ;
46900 char * kwnames[] = {
46901 (char *) "self",(char *) "item", NULL
46902 };
46903
46904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46906 if (!SWIG_IsOK(res1)) {
46907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46908 }
46909 arg1 = reinterpret_cast< wxSizer * >(argp1);
46910 arg2 = obj1;
46911 {
46912 PyThreadState* __tstate = wxPyBeginAllowThreads();
46913 result = (bool)wxSizer_Remove(arg1,arg2);
46914 wxPyEndAllowThreads(__tstate);
46915 if (PyErr_Occurred()) SWIG_fail;
46916 }
46917 {
46918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46919 }
46920 return resultobj;
46921 fail:
46922 return NULL;
46923 }
46924
46925
46926 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46927 PyObject *resultobj = 0;
46928 wxSizer *arg1 = (wxSizer *) 0 ;
46929 PyObject *arg2 = (PyObject *) 0 ;
46930 bool result;
46931 void *argp1 = 0 ;
46932 int res1 = 0 ;
46933 PyObject * obj0 = 0 ;
46934 PyObject * obj1 = 0 ;
46935 char * kwnames[] = {
46936 (char *) "self",(char *) "item", NULL
46937 };
46938
46939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46941 if (!SWIG_IsOK(res1)) {
46942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46943 }
46944 arg1 = reinterpret_cast< wxSizer * >(argp1);
46945 arg2 = obj1;
46946 {
46947 PyThreadState* __tstate = wxPyBeginAllowThreads();
46948 result = (bool)wxSizer_Detach(arg1,arg2);
46949 wxPyEndAllowThreads(__tstate);
46950 if (PyErr_Occurred()) SWIG_fail;
46951 }
46952 {
46953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46954 }
46955 return resultobj;
46956 fail:
46957 return NULL;
46958 }
46959
46960
46961 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46962 PyObject *resultobj = 0;
46963 wxSizer *arg1 = (wxSizer *) 0 ;
46964 PyObject *arg2 = (PyObject *) 0 ;
46965 wxSizerItem *result = 0 ;
46966 void *argp1 = 0 ;
46967 int res1 = 0 ;
46968 PyObject * obj0 = 0 ;
46969 PyObject * obj1 = 0 ;
46970 char * kwnames[] = {
46971 (char *) "self",(char *) "item", NULL
46972 };
46973
46974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46976 if (!SWIG_IsOK(res1)) {
46977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46978 }
46979 arg1 = reinterpret_cast< wxSizer * >(argp1);
46980 arg2 = obj1;
46981 {
46982 PyThreadState* __tstate = wxPyBeginAllowThreads();
46983 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46984 wxPyEndAllowThreads(__tstate);
46985 if (PyErr_Occurred()) SWIG_fail;
46986 }
46987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46988 return resultobj;
46989 fail:
46990 return NULL;
46991 }
46992
46993
46994 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46995 PyObject *resultobj = 0;
46996 wxSizer *arg1 = (wxSizer *) 0 ;
46997 PyObject *arg2 = (PyObject *) 0 ;
46998 wxSize *arg3 = 0 ;
46999 void *argp1 = 0 ;
47000 int res1 = 0 ;
47001 wxSize temp3 ;
47002 PyObject * obj0 = 0 ;
47003 PyObject * obj1 = 0 ;
47004 PyObject * obj2 = 0 ;
47005 char * kwnames[] = {
47006 (char *) "self",(char *) "item",(char *) "size", NULL
47007 };
47008
47009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47011 if (!SWIG_IsOK(res1)) {
47012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47013 }
47014 arg1 = reinterpret_cast< wxSizer * >(argp1);
47015 arg2 = obj1;
47016 {
47017 arg3 = &temp3;
47018 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47019 }
47020 {
47021 PyThreadState* __tstate = wxPyBeginAllowThreads();
47022 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47023 wxPyEndAllowThreads(__tstate);
47024 if (PyErr_Occurred()) SWIG_fail;
47025 }
47026 resultobj = SWIG_Py_Void();
47027 return resultobj;
47028 fail:
47029 return NULL;
47030 }
47031
47032
47033 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47034 PyObject *resultobj = 0;
47035 wxSizer *arg1 = (wxSizer *) 0 ;
47036 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47037 wxSizerItem *result = 0 ;
47038 void *argp1 = 0 ;
47039 int res1 = 0 ;
47040 int res2 = 0 ;
47041 PyObject * obj0 = 0 ;
47042 PyObject * obj1 = 0 ;
47043 char * kwnames[] = {
47044 (char *) "self",(char *) "item", NULL
47045 };
47046
47047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47049 if (!SWIG_IsOK(res1)) {
47050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47051 }
47052 arg1 = reinterpret_cast< wxSizer * >(argp1);
47053 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47054 if (!SWIG_IsOK(res2)) {
47055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47056 }
47057 {
47058 PyThreadState* __tstate = wxPyBeginAllowThreads();
47059 result = (wxSizerItem *)(arg1)->Add(arg2);
47060 wxPyEndAllowThreads(__tstate);
47061 if (PyErr_Occurred()) SWIG_fail;
47062 }
47063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47064 return resultobj;
47065 fail:
47066 return NULL;
47067 }
47068
47069
47070 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47071 PyObject *resultobj = 0;
47072 wxSizer *arg1 = (wxSizer *) 0 ;
47073 size_t arg2 ;
47074 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47075 wxSizerItem *result = 0 ;
47076 void *argp1 = 0 ;
47077 int res1 = 0 ;
47078 size_t val2 ;
47079 int ecode2 = 0 ;
47080 int res3 = 0 ;
47081 PyObject * obj0 = 0 ;
47082 PyObject * obj1 = 0 ;
47083 PyObject * obj2 = 0 ;
47084 char * kwnames[] = {
47085 (char *) "self",(char *) "index",(char *) "item", NULL
47086 };
47087
47088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47090 if (!SWIG_IsOK(res1)) {
47091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47092 }
47093 arg1 = reinterpret_cast< wxSizer * >(argp1);
47094 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47095 if (!SWIG_IsOK(ecode2)) {
47096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47097 }
47098 arg2 = static_cast< size_t >(val2);
47099 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47100 if (!SWIG_IsOK(res3)) {
47101 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47102 }
47103 {
47104 PyThreadState* __tstate = wxPyBeginAllowThreads();
47105 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47106 wxPyEndAllowThreads(__tstate);
47107 if (PyErr_Occurred()) SWIG_fail;
47108 }
47109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47110 return resultobj;
47111 fail:
47112 return NULL;
47113 }
47114
47115
47116 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47117 PyObject *resultobj = 0;
47118 wxSizer *arg1 = (wxSizer *) 0 ;
47119 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47120 wxSizerItem *result = 0 ;
47121 void *argp1 = 0 ;
47122 int res1 = 0 ;
47123 int res2 = 0 ;
47124 PyObject * obj0 = 0 ;
47125 PyObject * obj1 = 0 ;
47126 char * kwnames[] = {
47127 (char *) "self",(char *) "item", NULL
47128 };
47129
47130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47132 if (!SWIG_IsOK(res1)) {
47133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47134 }
47135 arg1 = reinterpret_cast< wxSizer * >(argp1);
47136 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47137 if (!SWIG_IsOK(res2)) {
47138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47139 }
47140 {
47141 PyThreadState* __tstate = wxPyBeginAllowThreads();
47142 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47143 wxPyEndAllowThreads(__tstate);
47144 if (PyErr_Occurred()) SWIG_fail;
47145 }
47146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47147 return resultobj;
47148 fail:
47149 return NULL;
47150 }
47151
47152
47153 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47154 PyObject *resultobj = 0;
47155 wxSizer *arg1 = (wxSizer *) 0 ;
47156 int arg2 ;
47157 int arg3 ;
47158 int arg4 ;
47159 int arg5 ;
47160 void *argp1 = 0 ;
47161 int res1 = 0 ;
47162 int val2 ;
47163 int ecode2 = 0 ;
47164 int val3 ;
47165 int ecode3 = 0 ;
47166 int val4 ;
47167 int ecode4 = 0 ;
47168 int val5 ;
47169 int ecode5 = 0 ;
47170 PyObject * obj0 = 0 ;
47171 PyObject * obj1 = 0 ;
47172 PyObject * obj2 = 0 ;
47173 PyObject * obj3 = 0 ;
47174 PyObject * obj4 = 0 ;
47175 char * kwnames[] = {
47176 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47177 };
47178
47179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47181 if (!SWIG_IsOK(res1)) {
47182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47183 }
47184 arg1 = reinterpret_cast< wxSizer * >(argp1);
47185 ecode2 = SWIG_AsVal_int(obj1, &val2);
47186 if (!SWIG_IsOK(ecode2)) {
47187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47188 }
47189 arg2 = static_cast< int >(val2);
47190 ecode3 = SWIG_AsVal_int(obj2, &val3);
47191 if (!SWIG_IsOK(ecode3)) {
47192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47193 }
47194 arg3 = static_cast< int >(val3);
47195 ecode4 = SWIG_AsVal_int(obj3, &val4);
47196 if (!SWIG_IsOK(ecode4)) {
47197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47198 }
47199 arg4 = static_cast< int >(val4);
47200 ecode5 = SWIG_AsVal_int(obj4, &val5);
47201 if (!SWIG_IsOK(ecode5)) {
47202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47203 }
47204 arg5 = static_cast< int >(val5);
47205 {
47206 PyThreadState* __tstate = wxPyBeginAllowThreads();
47207 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47208 wxPyEndAllowThreads(__tstate);
47209 if (PyErr_Occurred()) SWIG_fail;
47210 }
47211 resultobj = SWIG_Py_Void();
47212 return resultobj;
47213 fail:
47214 return NULL;
47215 }
47216
47217
47218 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47219 PyObject *resultobj = 0;
47220 wxSizer *arg1 = (wxSizer *) 0 ;
47221 wxSize *arg2 = 0 ;
47222 void *argp1 = 0 ;
47223 int res1 = 0 ;
47224 wxSize temp2 ;
47225 PyObject * obj0 = 0 ;
47226 PyObject * obj1 = 0 ;
47227 char * kwnames[] = {
47228 (char *) "self",(char *) "size", NULL
47229 };
47230
47231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47233 if (!SWIG_IsOK(res1)) {
47234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47235 }
47236 arg1 = reinterpret_cast< wxSizer * >(argp1);
47237 {
47238 arg2 = &temp2;
47239 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47240 }
47241 {
47242 PyThreadState* __tstate = wxPyBeginAllowThreads();
47243 (arg1)->SetMinSize((wxSize const &)*arg2);
47244 wxPyEndAllowThreads(__tstate);
47245 if (PyErr_Occurred()) SWIG_fail;
47246 }
47247 resultobj = SWIG_Py_Void();
47248 return resultobj;
47249 fail:
47250 return NULL;
47251 }
47252
47253
47254 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47255 PyObject *resultobj = 0;
47256 wxSizer *arg1 = (wxSizer *) 0 ;
47257 wxSize result;
47258 void *argp1 = 0 ;
47259 int res1 = 0 ;
47260 PyObject *swig_obj[1] ;
47261
47262 if (!args) SWIG_fail;
47263 swig_obj[0] = args;
47264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47265 if (!SWIG_IsOK(res1)) {
47266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47267 }
47268 arg1 = reinterpret_cast< wxSizer * >(argp1);
47269 {
47270 PyThreadState* __tstate = wxPyBeginAllowThreads();
47271 result = (arg1)->GetSize();
47272 wxPyEndAllowThreads(__tstate);
47273 if (PyErr_Occurred()) SWIG_fail;
47274 }
47275 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47276 return resultobj;
47277 fail:
47278 return NULL;
47279 }
47280
47281
47282 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47283 PyObject *resultobj = 0;
47284 wxSizer *arg1 = (wxSizer *) 0 ;
47285 wxPoint result;
47286 void *argp1 = 0 ;
47287 int res1 = 0 ;
47288 PyObject *swig_obj[1] ;
47289
47290 if (!args) SWIG_fail;
47291 swig_obj[0] = args;
47292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47293 if (!SWIG_IsOK(res1)) {
47294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47295 }
47296 arg1 = reinterpret_cast< wxSizer * >(argp1);
47297 {
47298 PyThreadState* __tstate = wxPyBeginAllowThreads();
47299 result = (arg1)->GetPosition();
47300 wxPyEndAllowThreads(__tstate);
47301 if (PyErr_Occurred()) SWIG_fail;
47302 }
47303 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47304 return resultobj;
47305 fail:
47306 return NULL;
47307 }
47308
47309
47310 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47311 PyObject *resultobj = 0;
47312 wxSizer *arg1 = (wxSizer *) 0 ;
47313 wxSize result;
47314 void *argp1 = 0 ;
47315 int res1 = 0 ;
47316 PyObject *swig_obj[1] ;
47317
47318 if (!args) SWIG_fail;
47319 swig_obj[0] = args;
47320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47321 if (!SWIG_IsOK(res1)) {
47322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47323 }
47324 arg1 = reinterpret_cast< wxSizer * >(argp1);
47325 {
47326 PyThreadState* __tstate = wxPyBeginAllowThreads();
47327 result = (arg1)->GetMinSize();
47328 wxPyEndAllowThreads(__tstate);
47329 if (PyErr_Occurred()) SWIG_fail;
47330 }
47331 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47332 return resultobj;
47333 fail:
47334 return NULL;
47335 }
47336
47337
47338 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47339 PyObject *resultobj = 0;
47340 wxSizer *arg1 = (wxSizer *) 0 ;
47341 void *argp1 = 0 ;
47342 int res1 = 0 ;
47343 PyObject *swig_obj[1] ;
47344
47345 if (!args) SWIG_fail;
47346 swig_obj[0] = args;
47347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47348 if (!SWIG_IsOK(res1)) {
47349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47350 }
47351 arg1 = reinterpret_cast< wxSizer * >(argp1);
47352 {
47353 PyThreadState* __tstate = wxPyBeginAllowThreads();
47354 (arg1)->RecalcSizes();
47355 wxPyEndAllowThreads(__tstate);
47356 if (PyErr_Occurred()) SWIG_fail;
47357 }
47358 resultobj = SWIG_Py_Void();
47359 return resultobj;
47360 fail:
47361 return NULL;
47362 }
47363
47364
47365 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47366 PyObject *resultobj = 0;
47367 wxSizer *arg1 = (wxSizer *) 0 ;
47368 wxSize result;
47369 void *argp1 = 0 ;
47370 int res1 = 0 ;
47371 PyObject *swig_obj[1] ;
47372
47373 if (!args) SWIG_fail;
47374 swig_obj[0] = args;
47375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47376 if (!SWIG_IsOK(res1)) {
47377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47378 }
47379 arg1 = reinterpret_cast< wxSizer * >(argp1);
47380 {
47381 PyThreadState* __tstate = wxPyBeginAllowThreads();
47382 result = (arg1)->CalcMin();
47383 wxPyEndAllowThreads(__tstate);
47384 if (PyErr_Occurred()) SWIG_fail;
47385 }
47386 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47387 return resultobj;
47388 fail:
47389 return NULL;
47390 }
47391
47392
47393 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47394 PyObject *resultobj = 0;
47395 wxSizer *arg1 = (wxSizer *) 0 ;
47396 void *argp1 = 0 ;
47397 int res1 = 0 ;
47398 PyObject *swig_obj[1] ;
47399
47400 if (!args) SWIG_fail;
47401 swig_obj[0] = args;
47402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47403 if (!SWIG_IsOK(res1)) {
47404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47405 }
47406 arg1 = reinterpret_cast< wxSizer * >(argp1);
47407 {
47408 PyThreadState* __tstate = wxPyBeginAllowThreads();
47409 (arg1)->Layout();
47410 wxPyEndAllowThreads(__tstate);
47411 if (PyErr_Occurred()) SWIG_fail;
47412 }
47413 resultobj = SWIG_Py_Void();
47414 return resultobj;
47415 fail:
47416 return NULL;
47417 }
47418
47419
47420 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47421 PyObject *resultobj = 0;
47422 wxSizer *arg1 = (wxSizer *) 0 ;
47423 wxWindow *arg2 = (wxWindow *) 0 ;
47424 wxSize result;
47425 void *argp1 = 0 ;
47426 int res1 = 0 ;
47427 void *argp2 = 0 ;
47428 int res2 = 0 ;
47429 PyObject * obj0 = 0 ;
47430 PyObject * obj1 = 0 ;
47431 char * kwnames[] = {
47432 (char *) "self",(char *) "window", NULL
47433 };
47434
47435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47437 if (!SWIG_IsOK(res1)) {
47438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47439 }
47440 arg1 = reinterpret_cast< wxSizer * >(argp1);
47441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47442 if (!SWIG_IsOK(res2)) {
47443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47444 }
47445 arg2 = reinterpret_cast< wxWindow * >(argp2);
47446 {
47447 PyThreadState* __tstate = wxPyBeginAllowThreads();
47448 result = (arg1)->Fit(arg2);
47449 wxPyEndAllowThreads(__tstate);
47450 if (PyErr_Occurred()) SWIG_fail;
47451 }
47452 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47453 return resultobj;
47454 fail:
47455 return NULL;
47456 }
47457
47458
47459 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47460 PyObject *resultobj = 0;
47461 wxSizer *arg1 = (wxSizer *) 0 ;
47462 wxWindow *arg2 = (wxWindow *) 0 ;
47463 void *argp1 = 0 ;
47464 int res1 = 0 ;
47465 void *argp2 = 0 ;
47466 int res2 = 0 ;
47467 PyObject * obj0 = 0 ;
47468 PyObject * obj1 = 0 ;
47469 char * kwnames[] = {
47470 (char *) "self",(char *) "window", NULL
47471 };
47472
47473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47475 if (!SWIG_IsOK(res1)) {
47476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47477 }
47478 arg1 = reinterpret_cast< wxSizer * >(argp1);
47479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47480 if (!SWIG_IsOK(res2)) {
47481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47482 }
47483 arg2 = reinterpret_cast< wxWindow * >(argp2);
47484 {
47485 PyThreadState* __tstate = wxPyBeginAllowThreads();
47486 (arg1)->FitInside(arg2);
47487 wxPyEndAllowThreads(__tstate);
47488 if (PyErr_Occurred()) SWIG_fail;
47489 }
47490 resultobj = SWIG_Py_Void();
47491 return resultobj;
47492 fail:
47493 return NULL;
47494 }
47495
47496
47497 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47498 PyObject *resultobj = 0;
47499 wxSizer *arg1 = (wxSizer *) 0 ;
47500 wxWindow *arg2 = (wxWindow *) 0 ;
47501 void *argp1 = 0 ;
47502 int res1 = 0 ;
47503 void *argp2 = 0 ;
47504 int res2 = 0 ;
47505 PyObject * obj0 = 0 ;
47506 PyObject * obj1 = 0 ;
47507 char * kwnames[] = {
47508 (char *) "self",(char *) "window", NULL
47509 };
47510
47511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47513 if (!SWIG_IsOK(res1)) {
47514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47515 }
47516 arg1 = reinterpret_cast< wxSizer * >(argp1);
47517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47518 if (!SWIG_IsOK(res2)) {
47519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47520 }
47521 arg2 = reinterpret_cast< wxWindow * >(argp2);
47522 {
47523 PyThreadState* __tstate = wxPyBeginAllowThreads();
47524 (arg1)->SetSizeHints(arg2);
47525 wxPyEndAllowThreads(__tstate);
47526 if (PyErr_Occurred()) SWIG_fail;
47527 }
47528 resultobj = SWIG_Py_Void();
47529 return resultobj;
47530 fail:
47531 return NULL;
47532 }
47533
47534
47535 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47536 PyObject *resultobj = 0;
47537 wxSizer *arg1 = (wxSizer *) 0 ;
47538 wxWindow *arg2 = (wxWindow *) 0 ;
47539 void *argp1 = 0 ;
47540 int res1 = 0 ;
47541 void *argp2 = 0 ;
47542 int res2 = 0 ;
47543 PyObject * obj0 = 0 ;
47544 PyObject * obj1 = 0 ;
47545 char * kwnames[] = {
47546 (char *) "self",(char *) "window", NULL
47547 };
47548
47549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47551 if (!SWIG_IsOK(res1)) {
47552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47553 }
47554 arg1 = reinterpret_cast< wxSizer * >(argp1);
47555 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47556 if (!SWIG_IsOK(res2)) {
47557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47558 }
47559 arg2 = reinterpret_cast< wxWindow * >(argp2);
47560 {
47561 PyThreadState* __tstate = wxPyBeginAllowThreads();
47562 (arg1)->SetVirtualSizeHints(arg2);
47563 wxPyEndAllowThreads(__tstate);
47564 if (PyErr_Occurred()) SWIG_fail;
47565 }
47566 resultobj = SWIG_Py_Void();
47567 return resultobj;
47568 fail:
47569 return NULL;
47570 }
47571
47572
47573 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47574 PyObject *resultobj = 0;
47575 wxSizer *arg1 = (wxSizer *) 0 ;
47576 bool arg2 = (bool) false ;
47577 void *argp1 = 0 ;
47578 int res1 = 0 ;
47579 bool val2 ;
47580 int ecode2 = 0 ;
47581 PyObject * obj0 = 0 ;
47582 PyObject * obj1 = 0 ;
47583 char * kwnames[] = {
47584 (char *) "self",(char *) "deleteWindows", NULL
47585 };
47586
47587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47589 if (!SWIG_IsOK(res1)) {
47590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47591 }
47592 arg1 = reinterpret_cast< wxSizer * >(argp1);
47593 if (obj1) {
47594 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47595 if (!SWIG_IsOK(ecode2)) {
47596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47597 }
47598 arg2 = static_cast< bool >(val2);
47599 }
47600 {
47601 PyThreadState* __tstate = wxPyBeginAllowThreads();
47602 (arg1)->Clear(arg2);
47603 wxPyEndAllowThreads(__tstate);
47604 if (PyErr_Occurred()) SWIG_fail;
47605 }
47606 resultobj = SWIG_Py_Void();
47607 return resultobj;
47608 fail:
47609 return NULL;
47610 }
47611
47612
47613 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47614 PyObject *resultobj = 0;
47615 wxSizer *arg1 = (wxSizer *) 0 ;
47616 void *argp1 = 0 ;
47617 int res1 = 0 ;
47618 PyObject *swig_obj[1] ;
47619
47620 if (!args) SWIG_fail;
47621 swig_obj[0] = args;
47622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47623 if (!SWIG_IsOK(res1)) {
47624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47625 }
47626 arg1 = reinterpret_cast< wxSizer * >(argp1);
47627 {
47628 PyThreadState* __tstate = wxPyBeginAllowThreads();
47629 (arg1)->DeleteWindows();
47630 wxPyEndAllowThreads(__tstate);
47631 if (PyErr_Occurred()) SWIG_fail;
47632 }
47633 resultobj = SWIG_Py_Void();
47634 return resultobj;
47635 fail:
47636 return NULL;
47637 }
47638
47639
47640 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47641 PyObject *resultobj = 0;
47642 wxSizer *arg1 = (wxSizer *) 0 ;
47643 PyObject *result = 0 ;
47644 void *argp1 = 0 ;
47645 int res1 = 0 ;
47646 PyObject *swig_obj[1] ;
47647
47648 if (!args) SWIG_fail;
47649 swig_obj[0] = args;
47650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47651 if (!SWIG_IsOK(res1)) {
47652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47653 }
47654 arg1 = reinterpret_cast< wxSizer * >(argp1);
47655 {
47656 PyThreadState* __tstate = wxPyBeginAllowThreads();
47657 result = (PyObject *)wxSizer_GetChildren(arg1);
47658 wxPyEndAllowThreads(__tstate);
47659 if (PyErr_Occurred()) SWIG_fail;
47660 }
47661 resultobj = result;
47662 return resultobj;
47663 fail:
47664 return NULL;
47665 }
47666
47667
47668 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47669 PyObject *resultobj = 0;
47670 wxSizer *arg1 = (wxSizer *) 0 ;
47671 PyObject *arg2 = (PyObject *) 0 ;
47672 bool arg3 = (bool) true ;
47673 bool arg4 = (bool) false ;
47674 bool result;
47675 void *argp1 = 0 ;
47676 int res1 = 0 ;
47677 bool val3 ;
47678 int ecode3 = 0 ;
47679 bool val4 ;
47680 int ecode4 = 0 ;
47681 PyObject * obj0 = 0 ;
47682 PyObject * obj1 = 0 ;
47683 PyObject * obj2 = 0 ;
47684 PyObject * obj3 = 0 ;
47685 char * kwnames[] = {
47686 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47687 };
47688
47689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47691 if (!SWIG_IsOK(res1)) {
47692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47693 }
47694 arg1 = reinterpret_cast< wxSizer * >(argp1);
47695 arg2 = obj1;
47696 if (obj2) {
47697 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47698 if (!SWIG_IsOK(ecode3)) {
47699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47700 }
47701 arg3 = static_cast< bool >(val3);
47702 }
47703 if (obj3) {
47704 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47705 if (!SWIG_IsOK(ecode4)) {
47706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47707 }
47708 arg4 = static_cast< bool >(val4);
47709 }
47710 {
47711 PyThreadState* __tstate = wxPyBeginAllowThreads();
47712 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47713 wxPyEndAllowThreads(__tstate);
47714 if (PyErr_Occurred()) SWIG_fail;
47715 }
47716 {
47717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47718 }
47719 return resultobj;
47720 fail:
47721 return NULL;
47722 }
47723
47724
47725 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47726 PyObject *resultobj = 0;
47727 wxSizer *arg1 = (wxSizer *) 0 ;
47728 PyObject *arg2 = (PyObject *) 0 ;
47729 bool result;
47730 void *argp1 = 0 ;
47731 int res1 = 0 ;
47732 PyObject * obj0 = 0 ;
47733 PyObject * obj1 = 0 ;
47734 char * kwnames[] = {
47735 (char *) "self",(char *) "item", NULL
47736 };
47737
47738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) 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_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47742 }
47743 arg1 = reinterpret_cast< wxSizer * >(argp1);
47744 arg2 = obj1;
47745 {
47746 PyThreadState* __tstate = wxPyBeginAllowThreads();
47747 result = (bool)wxSizer_IsShown(arg1,arg2);
47748 wxPyEndAllowThreads(__tstate);
47749 if (PyErr_Occurred()) SWIG_fail;
47750 }
47751 {
47752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47753 }
47754 return resultobj;
47755 fail:
47756 return NULL;
47757 }
47758
47759
47760 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47761 PyObject *resultobj = 0;
47762 wxSizer *arg1 = (wxSizer *) 0 ;
47763 bool arg2 ;
47764 void *argp1 = 0 ;
47765 int res1 = 0 ;
47766 bool val2 ;
47767 int ecode2 = 0 ;
47768 PyObject * obj0 = 0 ;
47769 PyObject * obj1 = 0 ;
47770 char * kwnames[] = {
47771 (char *) "self",(char *) "show", NULL
47772 };
47773
47774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47776 if (!SWIG_IsOK(res1)) {
47777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47778 }
47779 arg1 = reinterpret_cast< wxSizer * >(argp1);
47780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47781 if (!SWIG_IsOK(ecode2)) {
47782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47783 }
47784 arg2 = static_cast< bool >(val2);
47785 {
47786 PyThreadState* __tstate = wxPyBeginAllowThreads();
47787 (arg1)->ShowItems(arg2);
47788 wxPyEndAllowThreads(__tstate);
47789 if (PyErr_Occurred()) SWIG_fail;
47790 }
47791 resultobj = SWIG_Py_Void();
47792 return resultobj;
47793 fail:
47794 return NULL;
47795 }
47796
47797
47798 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47799 PyObject *obj;
47800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47801 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47802 return SWIG_Py_Void();
47803 }
47804
47805 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47806 PyObject *resultobj = 0;
47807 wxPySizer *result = 0 ;
47808
47809 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47810 {
47811 PyThreadState* __tstate = wxPyBeginAllowThreads();
47812 result = (wxPySizer *)new wxPySizer();
47813 wxPyEndAllowThreads(__tstate);
47814 if (PyErr_Occurred()) SWIG_fail;
47815 }
47816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47817 return resultobj;
47818 fail:
47819 return NULL;
47820 }
47821
47822
47823 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47824 PyObject *resultobj = 0;
47825 wxPySizer *arg1 = (wxPySizer *) 0 ;
47826 PyObject *arg2 = (PyObject *) 0 ;
47827 PyObject *arg3 = (PyObject *) 0 ;
47828 void *argp1 = 0 ;
47829 int res1 = 0 ;
47830 PyObject * obj0 = 0 ;
47831 PyObject * obj1 = 0 ;
47832 PyObject * obj2 = 0 ;
47833 char * kwnames[] = {
47834 (char *) "self",(char *) "self",(char *) "_class", NULL
47835 };
47836
47837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47839 if (!SWIG_IsOK(res1)) {
47840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47841 }
47842 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47843 arg2 = obj1;
47844 arg3 = obj2;
47845 {
47846 PyThreadState* __tstate = wxPyBeginAllowThreads();
47847 (arg1)->_setCallbackInfo(arg2,arg3);
47848 wxPyEndAllowThreads(__tstate);
47849 if (PyErr_Occurred()) SWIG_fail;
47850 }
47851 resultobj = SWIG_Py_Void();
47852 return resultobj;
47853 fail:
47854 return NULL;
47855 }
47856
47857
47858 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47859 PyObject *obj;
47860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47861 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47862 return SWIG_Py_Void();
47863 }
47864
47865 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47866 return SWIG_Python_InitShadowInstance(args);
47867 }
47868
47869 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47870 PyObject *resultobj = 0;
47871 int arg1 = (int) wxHORIZONTAL ;
47872 wxBoxSizer *result = 0 ;
47873 int val1 ;
47874 int ecode1 = 0 ;
47875 PyObject * obj0 = 0 ;
47876 char * kwnames[] = {
47877 (char *) "orient", NULL
47878 };
47879
47880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47881 if (obj0) {
47882 ecode1 = SWIG_AsVal_int(obj0, &val1);
47883 if (!SWIG_IsOK(ecode1)) {
47884 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47885 }
47886 arg1 = static_cast< int >(val1);
47887 }
47888 {
47889 PyThreadState* __tstate = wxPyBeginAllowThreads();
47890 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47891 wxPyEndAllowThreads(__tstate);
47892 if (PyErr_Occurred()) SWIG_fail;
47893 }
47894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47895 return resultobj;
47896 fail:
47897 return NULL;
47898 }
47899
47900
47901 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47902 PyObject *resultobj = 0;
47903 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47904 int result;
47905 void *argp1 = 0 ;
47906 int res1 = 0 ;
47907 PyObject *swig_obj[1] ;
47908
47909 if (!args) SWIG_fail;
47910 swig_obj[0] = args;
47911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47912 if (!SWIG_IsOK(res1)) {
47913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47914 }
47915 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47916 {
47917 PyThreadState* __tstate = wxPyBeginAllowThreads();
47918 result = (int)(arg1)->GetOrientation();
47919 wxPyEndAllowThreads(__tstate);
47920 if (PyErr_Occurred()) SWIG_fail;
47921 }
47922 resultobj = SWIG_From_int(static_cast< int >(result));
47923 return resultobj;
47924 fail:
47925 return NULL;
47926 }
47927
47928
47929 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47930 PyObject *resultobj = 0;
47931 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47932 int arg2 ;
47933 void *argp1 = 0 ;
47934 int res1 = 0 ;
47935 int val2 ;
47936 int ecode2 = 0 ;
47937 PyObject * obj0 = 0 ;
47938 PyObject * obj1 = 0 ;
47939 char * kwnames[] = {
47940 (char *) "self",(char *) "orient", NULL
47941 };
47942
47943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47945 if (!SWIG_IsOK(res1)) {
47946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47947 }
47948 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47949 ecode2 = SWIG_AsVal_int(obj1, &val2);
47950 if (!SWIG_IsOK(ecode2)) {
47951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47952 }
47953 arg2 = static_cast< int >(val2);
47954 {
47955 PyThreadState* __tstate = wxPyBeginAllowThreads();
47956 (arg1)->SetOrientation(arg2);
47957 wxPyEndAllowThreads(__tstate);
47958 if (PyErr_Occurred()) SWIG_fail;
47959 }
47960 resultobj = SWIG_Py_Void();
47961 return resultobj;
47962 fail:
47963 return NULL;
47964 }
47965
47966
47967 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47968 PyObject *obj;
47969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47970 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47971 return SWIG_Py_Void();
47972 }
47973
47974 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47975 return SWIG_Python_InitShadowInstance(args);
47976 }
47977
47978 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47979 PyObject *resultobj = 0;
47980 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47981 int arg2 = (int) wxHORIZONTAL ;
47982 wxStaticBoxSizer *result = 0 ;
47983 void *argp1 = 0 ;
47984 int res1 = 0 ;
47985 int val2 ;
47986 int ecode2 = 0 ;
47987 PyObject * obj0 = 0 ;
47988 PyObject * obj1 = 0 ;
47989 char * kwnames[] = {
47990 (char *) "box",(char *) "orient", NULL
47991 };
47992
47993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47995 if (!SWIG_IsOK(res1)) {
47996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47997 }
47998 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47999 if (obj1) {
48000 ecode2 = SWIG_AsVal_int(obj1, &val2);
48001 if (!SWIG_IsOK(ecode2)) {
48002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48003 }
48004 arg2 = static_cast< int >(val2);
48005 }
48006 {
48007 PyThreadState* __tstate = wxPyBeginAllowThreads();
48008 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48009 wxPyEndAllowThreads(__tstate);
48010 if (PyErr_Occurred()) SWIG_fail;
48011 }
48012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48013 return resultobj;
48014 fail:
48015 return NULL;
48016 }
48017
48018
48019 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48020 PyObject *resultobj = 0;
48021 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48022 wxStaticBox *result = 0 ;
48023 void *argp1 = 0 ;
48024 int res1 = 0 ;
48025 PyObject *swig_obj[1] ;
48026
48027 if (!args) SWIG_fail;
48028 swig_obj[0] = args;
48029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48030 if (!SWIG_IsOK(res1)) {
48031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48032 }
48033 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48034 {
48035 PyThreadState* __tstate = wxPyBeginAllowThreads();
48036 result = (wxStaticBox *)(arg1)->GetStaticBox();
48037 wxPyEndAllowThreads(__tstate);
48038 if (PyErr_Occurred()) SWIG_fail;
48039 }
48040 {
48041 resultobj = wxPyMake_wxObject(result, (bool)0);
48042 }
48043 return resultobj;
48044 fail:
48045 return NULL;
48046 }
48047
48048
48049 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48050 PyObject *obj;
48051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48052 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48053 return SWIG_Py_Void();
48054 }
48055
48056 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48057 return SWIG_Python_InitShadowInstance(args);
48058 }
48059
48060 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48061 PyObject *resultobj = 0;
48062 int arg1 = (int) 1 ;
48063 int arg2 = (int) 0 ;
48064 int arg3 = (int) 0 ;
48065 int arg4 = (int) 0 ;
48066 wxGridSizer *result = 0 ;
48067 int val1 ;
48068 int ecode1 = 0 ;
48069 int val2 ;
48070 int ecode2 = 0 ;
48071 int val3 ;
48072 int ecode3 = 0 ;
48073 int val4 ;
48074 int ecode4 = 0 ;
48075 PyObject * obj0 = 0 ;
48076 PyObject * obj1 = 0 ;
48077 PyObject * obj2 = 0 ;
48078 PyObject * obj3 = 0 ;
48079 char * kwnames[] = {
48080 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48081 };
48082
48083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48084 if (obj0) {
48085 ecode1 = SWIG_AsVal_int(obj0, &val1);
48086 if (!SWIG_IsOK(ecode1)) {
48087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48088 }
48089 arg1 = static_cast< int >(val1);
48090 }
48091 if (obj1) {
48092 ecode2 = SWIG_AsVal_int(obj1, &val2);
48093 if (!SWIG_IsOK(ecode2)) {
48094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48095 }
48096 arg2 = static_cast< int >(val2);
48097 }
48098 if (obj2) {
48099 ecode3 = SWIG_AsVal_int(obj2, &val3);
48100 if (!SWIG_IsOK(ecode3)) {
48101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48102 }
48103 arg3 = static_cast< int >(val3);
48104 }
48105 if (obj3) {
48106 ecode4 = SWIG_AsVal_int(obj3, &val4);
48107 if (!SWIG_IsOK(ecode4)) {
48108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48109 }
48110 arg4 = static_cast< int >(val4);
48111 }
48112 {
48113 PyThreadState* __tstate = wxPyBeginAllowThreads();
48114 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48115 wxPyEndAllowThreads(__tstate);
48116 if (PyErr_Occurred()) SWIG_fail;
48117 }
48118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48119 return resultobj;
48120 fail:
48121 return NULL;
48122 }
48123
48124
48125 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48126 PyObject *resultobj = 0;
48127 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48128 int arg2 ;
48129 void *argp1 = 0 ;
48130 int res1 = 0 ;
48131 int val2 ;
48132 int ecode2 = 0 ;
48133 PyObject * obj0 = 0 ;
48134 PyObject * obj1 = 0 ;
48135 char * kwnames[] = {
48136 (char *) "self",(char *) "cols", NULL
48137 };
48138
48139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48141 if (!SWIG_IsOK(res1)) {
48142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48143 }
48144 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48145 ecode2 = SWIG_AsVal_int(obj1, &val2);
48146 if (!SWIG_IsOK(ecode2)) {
48147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48148 }
48149 arg2 = static_cast< int >(val2);
48150 {
48151 PyThreadState* __tstate = wxPyBeginAllowThreads();
48152 (arg1)->SetCols(arg2);
48153 wxPyEndAllowThreads(__tstate);
48154 if (PyErr_Occurred()) SWIG_fail;
48155 }
48156 resultobj = SWIG_Py_Void();
48157 return resultobj;
48158 fail:
48159 return NULL;
48160 }
48161
48162
48163 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48164 PyObject *resultobj = 0;
48165 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48166 int arg2 ;
48167 void *argp1 = 0 ;
48168 int res1 = 0 ;
48169 int val2 ;
48170 int ecode2 = 0 ;
48171 PyObject * obj0 = 0 ;
48172 PyObject * obj1 = 0 ;
48173 char * kwnames[] = {
48174 (char *) "self",(char *) "rows", NULL
48175 };
48176
48177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48179 if (!SWIG_IsOK(res1)) {
48180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48181 }
48182 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48183 ecode2 = SWIG_AsVal_int(obj1, &val2);
48184 if (!SWIG_IsOK(ecode2)) {
48185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48186 }
48187 arg2 = static_cast< int >(val2);
48188 {
48189 PyThreadState* __tstate = wxPyBeginAllowThreads();
48190 (arg1)->SetRows(arg2);
48191 wxPyEndAllowThreads(__tstate);
48192 if (PyErr_Occurred()) SWIG_fail;
48193 }
48194 resultobj = SWIG_Py_Void();
48195 return resultobj;
48196 fail:
48197 return NULL;
48198 }
48199
48200
48201 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48202 PyObject *resultobj = 0;
48203 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48204 int arg2 ;
48205 void *argp1 = 0 ;
48206 int res1 = 0 ;
48207 int val2 ;
48208 int ecode2 = 0 ;
48209 PyObject * obj0 = 0 ;
48210 PyObject * obj1 = 0 ;
48211 char * kwnames[] = {
48212 (char *) "self",(char *) "gap", NULL
48213 };
48214
48215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48217 if (!SWIG_IsOK(res1)) {
48218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48219 }
48220 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48221 ecode2 = SWIG_AsVal_int(obj1, &val2);
48222 if (!SWIG_IsOK(ecode2)) {
48223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48224 }
48225 arg2 = static_cast< int >(val2);
48226 {
48227 PyThreadState* __tstate = wxPyBeginAllowThreads();
48228 (arg1)->SetVGap(arg2);
48229 wxPyEndAllowThreads(__tstate);
48230 if (PyErr_Occurred()) SWIG_fail;
48231 }
48232 resultobj = SWIG_Py_Void();
48233 return resultobj;
48234 fail:
48235 return NULL;
48236 }
48237
48238
48239 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48240 PyObject *resultobj = 0;
48241 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48242 int arg2 ;
48243 void *argp1 = 0 ;
48244 int res1 = 0 ;
48245 int val2 ;
48246 int ecode2 = 0 ;
48247 PyObject * obj0 = 0 ;
48248 PyObject * obj1 = 0 ;
48249 char * kwnames[] = {
48250 (char *) "self",(char *) "gap", NULL
48251 };
48252
48253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48255 if (!SWIG_IsOK(res1)) {
48256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48257 }
48258 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48259 ecode2 = SWIG_AsVal_int(obj1, &val2);
48260 if (!SWIG_IsOK(ecode2)) {
48261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48262 }
48263 arg2 = static_cast< int >(val2);
48264 {
48265 PyThreadState* __tstate = wxPyBeginAllowThreads();
48266 (arg1)->SetHGap(arg2);
48267 wxPyEndAllowThreads(__tstate);
48268 if (PyErr_Occurred()) SWIG_fail;
48269 }
48270 resultobj = SWIG_Py_Void();
48271 return resultobj;
48272 fail:
48273 return NULL;
48274 }
48275
48276
48277 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48278 PyObject *resultobj = 0;
48279 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48280 int result;
48281 void *argp1 = 0 ;
48282 int res1 = 0 ;
48283 PyObject *swig_obj[1] ;
48284
48285 if (!args) SWIG_fail;
48286 swig_obj[0] = args;
48287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48288 if (!SWIG_IsOK(res1)) {
48289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48290 }
48291 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48292 {
48293 PyThreadState* __tstate = wxPyBeginAllowThreads();
48294 result = (int)(arg1)->GetCols();
48295 wxPyEndAllowThreads(__tstate);
48296 if (PyErr_Occurred()) SWIG_fail;
48297 }
48298 resultobj = SWIG_From_int(static_cast< int >(result));
48299 return resultobj;
48300 fail:
48301 return NULL;
48302 }
48303
48304
48305 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48306 PyObject *resultobj = 0;
48307 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48308 int result;
48309 void *argp1 = 0 ;
48310 int res1 = 0 ;
48311 PyObject *swig_obj[1] ;
48312
48313 if (!args) SWIG_fail;
48314 swig_obj[0] = args;
48315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48316 if (!SWIG_IsOK(res1)) {
48317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48318 }
48319 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48320 {
48321 PyThreadState* __tstate = wxPyBeginAllowThreads();
48322 result = (int)(arg1)->GetRows();
48323 wxPyEndAllowThreads(__tstate);
48324 if (PyErr_Occurred()) SWIG_fail;
48325 }
48326 resultobj = SWIG_From_int(static_cast< int >(result));
48327 return resultobj;
48328 fail:
48329 return NULL;
48330 }
48331
48332
48333 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48334 PyObject *resultobj = 0;
48335 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48336 int result;
48337 void *argp1 = 0 ;
48338 int res1 = 0 ;
48339 PyObject *swig_obj[1] ;
48340
48341 if (!args) SWIG_fail;
48342 swig_obj[0] = args;
48343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48344 if (!SWIG_IsOK(res1)) {
48345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48346 }
48347 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48348 {
48349 PyThreadState* __tstate = wxPyBeginAllowThreads();
48350 result = (int)(arg1)->GetVGap();
48351 wxPyEndAllowThreads(__tstate);
48352 if (PyErr_Occurred()) SWIG_fail;
48353 }
48354 resultobj = SWIG_From_int(static_cast< int >(result));
48355 return resultobj;
48356 fail:
48357 return NULL;
48358 }
48359
48360
48361 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48362 PyObject *resultobj = 0;
48363 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48364 int result;
48365 void *argp1 = 0 ;
48366 int res1 = 0 ;
48367 PyObject *swig_obj[1] ;
48368
48369 if (!args) SWIG_fail;
48370 swig_obj[0] = args;
48371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48372 if (!SWIG_IsOK(res1)) {
48373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48374 }
48375 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48376 {
48377 PyThreadState* __tstate = wxPyBeginAllowThreads();
48378 result = (int)(arg1)->GetHGap();
48379 wxPyEndAllowThreads(__tstate);
48380 if (PyErr_Occurred()) SWIG_fail;
48381 }
48382 resultobj = SWIG_From_int(static_cast< int >(result));
48383 return resultobj;
48384 fail:
48385 return NULL;
48386 }
48387
48388
48389 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48390 PyObject *obj;
48391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48392 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48393 return SWIG_Py_Void();
48394 }
48395
48396 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48397 return SWIG_Python_InitShadowInstance(args);
48398 }
48399
48400 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48401 PyObject *resultobj = 0;
48402 int arg1 = (int) 1 ;
48403 int arg2 = (int) 0 ;
48404 int arg3 = (int) 0 ;
48405 int arg4 = (int) 0 ;
48406 wxFlexGridSizer *result = 0 ;
48407 int val1 ;
48408 int ecode1 = 0 ;
48409 int val2 ;
48410 int ecode2 = 0 ;
48411 int val3 ;
48412 int ecode3 = 0 ;
48413 int val4 ;
48414 int ecode4 = 0 ;
48415 PyObject * obj0 = 0 ;
48416 PyObject * obj1 = 0 ;
48417 PyObject * obj2 = 0 ;
48418 PyObject * obj3 = 0 ;
48419 char * kwnames[] = {
48420 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48421 };
48422
48423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48424 if (obj0) {
48425 ecode1 = SWIG_AsVal_int(obj0, &val1);
48426 if (!SWIG_IsOK(ecode1)) {
48427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48428 }
48429 arg1 = static_cast< int >(val1);
48430 }
48431 if (obj1) {
48432 ecode2 = SWIG_AsVal_int(obj1, &val2);
48433 if (!SWIG_IsOK(ecode2)) {
48434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48435 }
48436 arg2 = static_cast< int >(val2);
48437 }
48438 if (obj2) {
48439 ecode3 = SWIG_AsVal_int(obj2, &val3);
48440 if (!SWIG_IsOK(ecode3)) {
48441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48442 }
48443 arg3 = static_cast< int >(val3);
48444 }
48445 if (obj3) {
48446 ecode4 = SWIG_AsVal_int(obj3, &val4);
48447 if (!SWIG_IsOK(ecode4)) {
48448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48449 }
48450 arg4 = static_cast< int >(val4);
48451 }
48452 {
48453 PyThreadState* __tstate = wxPyBeginAllowThreads();
48454 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48455 wxPyEndAllowThreads(__tstate);
48456 if (PyErr_Occurred()) SWIG_fail;
48457 }
48458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48459 return resultobj;
48460 fail:
48461 return NULL;
48462 }
48463
48464
48465 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48466 PyObject *resultobj = 0;
48467 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48468 size_t arg2 ;
48469 int arg3 = (int) 0 ;
48470 void *argp1 = 0 ;
48471 int res1 = 0 ;
48472 size_t val2 ;
48473 int ecode2 = 0 ;
48474 int val3 ;
48475 int ecode3 = 0 ;
48476 PyObject * obj0 = 0 ;
48477 PyObject * obj1 = 0 ;
48478 PyObject * obj2 = 0 ;
48479 char * kwnames[] = {
48480 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48481 };
48482
48483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48485 if (!SWIG_IsOK(res1)) {
48486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48487 }
48488 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48489 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48490 if (!SWIG_IsOK(ecode2)) {
48491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48492 }
48493 arg2 = static_cast< size_t >(val2);
48494 if (obj2) {
48495 ecode3 = SWIG_AsVal_int(obj2, &val3);
48496 if (!SWIG_IsOK(ecode3)) {
48497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48498 }
48499 arg3 = static_cast< int >(val3);
48500 }
48501 {
48502 PyThreadState* __tstate = wxPyBeginAllowThreads();
48503 (arg1)->AddGrowableRow(arg2,arg3);
48504 wxPyEndAllowThreads(__tstate);
48505 if (PyErr_Occurred()) SWIG_fail;
48506 }
48507 resultobj = SWIG_Py_Void();
48508 return resultobj;
48509 fail:
48510 return NULL;
48511 }
48512
48513
48514 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48515 PyObject *resultobj = 0;
48516 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48517 size_t arg2 ;
48518 void *argp1 = 0 ;
48519 int res1 = 0 ;
48520 size_t val2 ;
48521 int ecode2 = 0 ;
48522 PyObject * obj0 = 0 ;
48523 PyObject * obj1 = 0 ;
48524 char * kwnames[] = {
48525 (char *) "self",(char *) "idx", NULL
48526 };
48527
48528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48530 if (!SWIG_IsOK(res1)) {
48531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48532 }
48533 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48534 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48535 if (!SWIG_IsOK(ecode2)) {
48536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48537 }
48538 arg2 = static_cast< size_t >(val2);
48539 {
48540 PyThreadState* __tstate = wxPyBeginAllowThreads();
48541 (arg1)->RemoveGrowableRow(arg2);
48542 wxPyEndAllowThreads(__tstate);
48543 if (PyErr_Occurred()) SWIG_fail;
48544 }
48545 resultobj = SWIG_Py_Void();
48546 return resultobj;
48547 fail:
48548 return NULL;
48549 }
48550
48551
48552 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48553 PyObject *resultobj = 0;
48554 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48555 size_t arg2 ;
48556 int arg3 = (int) 0 ;
48557 void *argp1 = 0 ;
48558 int res1 = 0 ;
48559 size_t val2 ;
48560 int ecode2 = 0 ;
48561 int val3 ;
48562 int ecode3 = 0 ;
48563 PyObject * obj0 = 0 ;
48564 PyObject * obj1 = 0 ;
48565 PyObject * obj2 = 0 ;
48566 char * kwnames[] = {
48567 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48568 };
48569
48570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48572 if (!SWIG_IsOK(res1)) {
48573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48574 }
48575 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48576 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48577 if (!SWIG_IsOK(ecode2)) {
48578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48579 }
48580 arg2 = static_cast< size_t >(val2);
48581 if (obj2) {
48582 ecode3 = SWIG_AsVal_int(obj2, &val3);
48583 if (!SWIG_IsOK(ecode3)) {
48584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48585 }
48586 arg3 = static_cast< int >(val3);
48587 }
48588 {
48589 PyThreadState* __tstate = wxPyBeginAllowThreads();
48590 (arg1)->AddGrowableCol(arg2,arg3);
48591 wxPyEndAllowThreads(__tstate);
48592 if (PyErr_Occurred()) SWIG_fail;
48593 }
48594 resultobj = SWIG_Py_Void();
48595 return resultobj;
48596 fail:
48597 return NULL;
48598 }
48599
48600
48601 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48602 PyObject *resultobj = 0;
48603 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48604 size_t arg2 ;
48605 void *argp1 = 0 ;
48606 int res1 = 0 ;
48607 size_t val2 ;
48608 int ecode2 = 0 ;
48609 PyObject * obj0 = 0 ;
48610 PyObject * obj1 = 0 ;
48611 char * kwnames[] = {
48612 (char *) "self",(char *) "idx", NULL
48613 };
48614
48615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48617 if (!SWIG_IsOK(res1)) {
48618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48619 }
48620 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48621 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48622 if (!SWIG_IsOK(ecode2)) {
48623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48624 }
48625 arg2 = static_cast< size_t >(val2);
48626 {
48627 PyThreadState* __tstate = wxPyBeginAllowThreads();
48628 (arg1)->RemoveGrowableCol(arg2);
48629 wxPyEndAllowThreads(__tstate);
48630 if (PyErr_Occurred()) SWIG_fail;
48631 }
48632 resultobj = SWIG_Py_Void();
48633 return resultobj;
48634 fail:
48635 return NULL;
48636 }
48637
48638
48639 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48640 PyObject *resultobj = 0;
48641 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48642 int arg2 ;
48643 void *argp1 = 0 ;
48644 int res1 = 0 ;
48645 int val2 ;
48646 int ecode2 = 0 ;
48647 PyObject * obj0 = 0 ;
48648 PyObject * obj1 = 0 ;
48649 char * kwnames[] = {
48650 (char *) "self",(char *) "direction", NULL
48651 };
48652
48653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48655 if (!SWIG_IsOK(res1)) {
48656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48657 }
48658 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48659 ecode2 = SWIG_AsVal_int(obj1, &val2);
48660 if (!SWIG_IsOK(ecode2)) {
48661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48662 }
48663 arg2 = static_cast< int >(val2);
48664 {
48665 PyThreadState* __tstate = wxPyBeginAllowThreads();
48666 (arg1)->SetFlexibleDirection(arg2);
48667 wxPyEndAllowThreads(__tstate);
48668 if (PyErr_Occurred()) SWIG_fail;
48669 }
48670 resultobj = SWIG_Py_Void();
48671 return resultobj;
48672 fail:
48673 return NULL;
48674 }
48675
48676
48677 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48678 PyObject *resultobj = 0;
48679 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48680 int result;
48681 void *argp1 = 0 ;
48682 int res1 = 0 ;
48683 PyObject *swig_obj[1] ;
48684
48685 if (!args) SWIG_fail;
48686 swig_obj[0] = args;
48687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48688 if (!SWIG_IsOK(res1)) {
48689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48690 }
48691 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48692 {
48693 PyThreadState* __tstate = wxPyBeginAllowThreads();
48694 result = (int)(arg1)->GetFlexibleDirection();
48695 wxPyEndAllowThreads(__tstate);
48696 if (PyErr_Occurred()) SWIG_fail;
48697 }
48698 resultobj = SWIG_From_int(static_cast< int >(result));
48699 return resultobj;
48700 fail:
48701 return NULL;
48702 }
48703
48704
48705 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48706 PyObject *resultobj = 0;
48707 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48708 wxFlexSizerGrowMode arg2 ;
48709 void *argp1 = 0 ;
48710 int res1 = 0 ;
48711 int val2 ;
48712 int ecode2 = 0 ;
48713 PyObject * obj0 = 0 ;
48714 PyObject * obj1 = 0 ;
48715 char * kwnames[] = {
48716 (char *) "self",(char *) "mode", NULL
48717 };
48718
48719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48721 if (!SWIG_IsOK(res1)) {
48722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48723 }
48724 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48725 ecode2 = SWIG_AsVal_int(obj1, &val2);
48726 if (!SWIG_IsOK(ecode2)) {
48727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48728 }
48729 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48730 {
48731 PyThreadState* __tstate = wxPyBeginAllowThreads();
48732 (arg1)->SetNonFlexibleGrowMode(arg2);
48733 wxPyEndAllowThreads(__tstate);
48734 if (PyErr_Occurred()) SWIG_fail;
48735 }
48736 resultobj = SWIG_Py_Void();
48737 return resultobj;
48738 fail:
48739 return NULL;
48740 }
48741
48742
48743 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48744 PyObject *resultobj = 0;
48745 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48746 wxFlexSizerGrowMode result;
48747 void *argp1 = 0 ;
48748 int res1 = 0 ;
48749 PyObject *swig_obj[1] ;
48750
48751 if (!args) SWIG_fail;
48752 swig_obj[0] = args;
48753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48754 if (!SWIG_IsOK(res1)) {
48755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48756 }
48757 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48758 {
48759 PyThreadState* __tstate = wxPyBeginAllowThreads();
48760 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48761 wxPyEndAllowThreads(__tstate);
48762 if (PyErr_Occurred()) SWIG_fail;
48763 }
48764 resultobj = SWIG_From_int(static_cast< int >(result));
48765 return resultobj;
48766 fail:
48767 return NULL;
48768 }
48769
48770
48771 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48772 PyObject *resultobj = 0;
48773 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48774 wxArrayInt *result = 0 ;
48775 void *argp1 = 0 ;
48776 int res1 = 0 ;
48777 PyObject *swig_obj[1] ;
48778
48779 if (!args) SWIG_fail;
48780 swig_obj[0] = args;
48781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48782 if (!SWIG_IsOK(res1)) {
48783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48784 }
48785 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48786 {
48787 PyThreadState* __tstate = wxPyBeginAllowThreads();
48788 {
48789 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48790 result = (wxArrayInt *) &_result_ref;
48791 }
48792 wxPyEndAllowThreads(__tstate);
48793 if (PyErr_Occurred()) SWIG_fail;
48794 }
48795 {
48796 resultobj = PyList_New(0);
48797 size_t idx;
48798 for (idx = 0; idx < result->GetCount(); idx += 1) {
48799 PyObject* val = PyInt_FromLong( result->Item(idx) );
48800 PyList_Append(resultobj, val);
48801 Py_DECREF(val);
48802 }
48803 }
48804 return resultobj;
48805 fail:
48806 return NULL;
48807 }
48808
48809
48810 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48811 PyObject *resultobj = 0;
48812 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48813 wxArrayInt *result = 0 ;
48814 void *argp1 = 0 ;
48815 int res1 = 0 ;
48816 PyObject *swig_obj[1] ;
48817
48818 if (!args) SWIG_fail;
48819 swig_obj[0] = args;
48820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48821 if (!SWIG_IsOK(res1)) {
48822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48823 }
48824 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48825 {
48826 PyThreadState* __tstate = wxPyBeginAllowThreads();
48827 {
48828 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48829 result = (wxArrayInt *) &_result_ref;
48830 }
48831 wxPyEndAllowThreads(__tstate);
48832 if (PyErr_Occurred()) SWIG_fail;
48833 }
48834 {
48835 resultobj = PyList_New(0);
48836 size_t idx;
48837 for (idx = 0; idx < result->GetCount(); idx += 1) {
48838 PyObject* val = PyInt_FromLong( result->Item(idx) );
48839 PyList_Append(resultobj, val);
48840 Py_DECREF(val);
48841 }
48842 }
48843 return resultobj;
48844 fail:
48845 return NULL;
48846 }
48847
48848
48849 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48850 PyObject *obj;
48851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48852 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48853 return SWIG_Py_Void();
48854 }
48855
48856 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48857 return SWIG_Python_InitShadowInstance(args);
48858 }
48859
48860 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48861 PyObject *resultobj = 0;
48862 wxStdDialogButtonSizer *result = 0 ;
48863
48864 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48865 {
48866 PyThreadState* __tstate = wxPyBeginAllowThreads();
48867 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48868 wxPyEndAllowThreads(__tstate);
48869 if (PyErr_Occurred()) SWIG_fail;
48870 }
48871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48872 return resultobj;
48873 fail:
48874 return NULL;
48875 }
48876
48877
48878 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48879 PyObject *resultobj = 0;
48880 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48881 wxButton *arg2 = (wxButton *) 0 ;
48882 void *argp1 = 0 ;
48883 int res1 = 0 ;
48884 void *argp2 = 0 ;
48885 int res2 = 0 ;
48886 PyObject * obj0 = 0 ;
48887 PyObject * obj1 = 0 ;
48888 char * kwnames[] = {
48889 (char *) "self",(char *) "button", NULL
48890 };
48891
48892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48894 if (!SWIG_IsOK(res1)) {
48895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48896 }
48897 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48898 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48899 if (!SWIG_IsOK(res2)) {
48900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48901 }
48902 arg2 = reinterpret_cast< wxButton * >(argp2);
48903 {
48904 PyThreadState* __tstate = wxPyBeginAllowThreads();
48905 (arg1)->AddButton(arg2);
48906 wxPyEndAllowThreads(__tstate);
48907 if (PyErr_Occurred()) SWIG_fail;
48908 }
48909 resultobj = SWIG_Py_Void();
48910 return resultobj;
48911 fail:
48912 return NULL;
48913 }
48914
48915
48916 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48917 PyObject *resultobj = 0;
48918 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48919 void *argp1 = 0 ;
48920 int res1 = 0 ;
48921 PyObject *swig_obj[1] ;
48922
48923 if (!args) SWIG_fail;
48924 swig_obj[0] = args;
48925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48926 if (!SWIG_IsOK(res1)) {
48927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48928 }
48929 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48930 {
48931 PyThreadState* __tstate = wxPyBeginAllowThreads();
48932 (arg1)->Realize();
48933 wxPyEndAllowThreads(__tstate);
48934 if (PyErr_Occurred()) SWIG_fail;
48935 }
48936 resultobj = SWIG_Py_Void();
48937 return resultobj;
48938 fail:
48939 return NULL;
48940 }
48941
48942
48943 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48944 PyObject *resultobj = 0;
48945 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48946 wxButton *arg2 = (wxButton *) 0 ;
48947 void *argp1 = 0 ;
48948 int res1 = 0 ;
48949 void *argp2 = 0 ;
48950 int res2 = 0 ;
48951 PyObject * obj0 = 0 ;
48952 PyObject * obj1 = 0 ;
48953 char * kwnames[] = {
48954 (char *) "self",(char *) "button", NULL
48955 };
48956
48957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48959 if (!SWIG_IsOK(res1)) {
48960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48961 }
48962 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48963 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48964 if (!SWIG_IsOK(res2)) {
48965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48966 }
48967 arg2 = reinterpret_cast< wxButton * >(argp2);
48968 {
48969 PyThreadState* __tstate = wxPyBeginAllowThreads();
48970 (arg1)->SetAffirmativeButton(arg2);
48971 wxPyEndAllowThreads(__tstate);
48972 if (PyErr_Occurred()) SWIG_fail;
48973 }
48974 resultobj = SWIG_Py_Void();
48975 return resultobj;
48976 fail:
48977 return NULL;
48978 }
48979
48980
48981 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48982 PyObject *resultobj = 0;
48983 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48984 wxButton *arg2 = (wxButton *) 0 ;
48985 void *argp1 = 0 ;
48986 int res1 = 0 ;
48987 void *argp2 = 0 ;
48988 int res2 = 0 ;
48989 PyObject * obj0 = 0 ;
48990 PyObject * obj1 = 0 ;
48991 char * kwnames[] = {
48992 (char *) "self",(char *) "button", NULL
48993 };
48994
48995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48997 if (!SWIG_IsOK(res1)) {
48998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48999 }
49000 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49001 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49002 if (!SWIG_IsOK(res2)) {
49003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49004 }
49005 arg2 = reinterpret_cast< wxButton * >(argp2);
49006 {
49007 PyThreadState* __tstate = wxPyBeginAllowThreads();
49008 (arg1)->SetNegativeButton(arg2);
49009 wxPyEndAllowThreads(__tstate);
49010 if (PyErr_Occurred()) SWIG_fail;
49011 }
49012 resultobj = SWIG_Py_Void();
49013 return resultobj;
49014 fail:
49015 return NULL;
49016 }
49017
49018
49019 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49020 PyObject *resultobj = 0;
49021 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49022 wxButton *arg2 = (wxButton *) 0 ;
49023 void *argp1 = 0 ;
49024 int res1 = 0 ;
49025 void *argp2 = 0 ;
49026 int res2 = 0 ;
49027 PyObject * obj0 = 0 ;
49028 PyObject * obj1 = 0 ;
49029 char * kwnames[] = {
49030 (char *) "self",(char *) "button", NULL
49031 };
49032
49033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49035 if (!SWIG_IsOK(res1)) {
49036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49037 }
49038 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49040 if (!SWIG_IsOK(res2)) {
49041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49042 }
49043 arg2 = reinterpret_cast< wxButton * >(argp2);
49044 {
49045 PyThreadState* __tstate = wxPyBeginAllowThreads();
49046 (arg1)->SetCancelButton(arg2);
49047 wxPyEndAllowThreads(__tstate);
49048 if (PyErr_Occurred()) SWIG_fail;
49049 }
49050 resultobj = SWIG_Py_Void();
49051 return resultobj;
49052 fail:
49053 return NULL;
49054 }
49055
49056
49057 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49058 PyObject *resultobj = 0;
49059 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49060 wxButton *result = 0 ;
49061 void *argp1 = 0 ;
49062 int res1 = 0 ;
49063 PyObject *swig_obj[1] ;
49064
49065 if (!args) SWIG_fail;
49066 swig_obj[0] = args;
49067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49068 if (!SWIG_IsOK(res1)) {
49069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49070 }
49071 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49072 {
49073 PyThreadState* __tstate = wxPyBeginAllowThreads();
49074 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49075 wxPyEndAllowThreads(__tstate);
49076 if (PyErr_Occurred()) SWIG_fail;
49077 }
49078 {
49079 resultobj = wxPyMake_wxObject(result, (bool)0);
49080 }
49081 return resultobj;
49082 fail:
49083 return NULL;
49084 }
49085
49086
49087 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49088 PyObject *resultobj = 0;
49089 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49090 wxButton *result = 0 ;
49091 void *argp1 = 0 ;
49092 int res1 = 0 ;
49093 PyObject *swig_obj[1] ;
49094
49095 if (!args) SWIG_fail;
49096 swig_obj[0] = args;
49097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49098 if (!SWIG_IsOK(res1)) {
49099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49100 }
49101 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49102 {
49103 PyThreadState* __tstate = wxPyBeginAllowThreads();
49104 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49105 wxPyEndAllowThreads(__tstate);
49106 if (PyErr_Occurred()) SWIG_fail;
49107 }
49108 {
49109 resultobj = wxPyMake_wxObject(result, (bool)0);
49110 }
49111 return resultobj;
49112 fail:
49113 return NULL;
49114 }
49115
49116
49117 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49118 PyObject *resultobj = 0;
49119 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49120 wxButton *result = 0 ;
49121 void *argp1 = 0 ;
49122 int res1 = 0 ;
49123 PyObject *swig_obj[1] ;
49124
49125 if (!args) SWIG_fail;
49126 swig_obj[0] = args;
49127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49128 if (!SWIG_IsOK(res1)) {
49129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49130 }
49131 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49132 {
49133 PyThreadState* __tstate = wxPyBeginAllowThreads();
49134 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49135 wxPyEndAllowThreads(__tstate);
49136 if (PyErr_Occurred()) SWIG_fail;
49137 }
49138 {
49139 resultobj = wxPyMake_wxObject(result, (bool)0);
49140 }
49141 return resultobj;
49142 fail:
49143 return NULL;
49144 }
49145
49146
49147 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49148 PyObject *resultobj = 0;
49149 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49150 wxButton *result = 0 ;
49151 void *argp1 = 0 ;
49152 int res1 = 0 ;
49153 PyObject *swig_obj[1] ;
49154
49155 if (!args) SWIG_fail;
49156 swig_obj[0] = args;
49157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49158 if (!SWIG_IsOK(res1)) {
49159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49160 }
49161 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49162 {
49163 PyThreadState* __tstate = wxPyBeginAllowThreads();
49164 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49165 wxPyEndAllowThreads(__tstate);
49166 if (PyErr_Occurred()) SWIG_fail;
49167 }
49168 {
49169 resultobj = wxPyMake_wxObject(result, (bool)0);
49170 }
49171 return resultobj;
49172 fail:
49173 return NULL;
49174 }
49175
49176
49177 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49178 PyObject *resultobj = 0;
49179 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49180 wxButton *result = 0 ;
49181 void *argp1 = 0 ;
49182 int res1 = 0 ;
49183 PyObject *swig_obj[1] ;
49184
49185 if (!args) SWIG_fail;
49186 swig_obj[0] = args;
49187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49188 if (!SWIG_IsOK(res1)) {
49189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49190 }
49191 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49192 {
49193 PyThreadState* __tstate = wxPyBeginAllowThreads();
49194 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49195 wxPyEndAllowThreads(__tstate);
49196 if (PyErr_Occurred()) SWIG_fail;
49197 }
49198 {
49199 resultobj = wxPyMake_wxObject(result, (bool)0);
49200 }
49201 return resultobj;
49202 fail:
49203 return NULL;
49204 }
49205
49206
49207 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49208 PyObject *obj;
49209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49210 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49211 return SWIG_Py_Void();
49212 }
49213
49214 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49215 return SWIG_Python_InitShadowInstance(args);
49216 }
49217
49218 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49219 PyObject *resultobj = 0;
49220 int arg1 = (int) 0 ;
49221 int arg2 = (int) 0 ;
49222 wxGBPosition *result = 0 ;
49223 int val1 ;
49224 int ecode1 = 0 ;
49225 int val2 ;
49226 int ecode2 = 0 ;
49227 PyObject * obj0 = 0 ;
49228 PyObject * obj1 = 0 ;
49229 char * kwnames[] = {
49230 (char *) "row",(char *) "col", NULL
49231 };
49232
49233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49234 if (obj0) {
49235 ecode1 = SWIG_AsVal_int(obj0, &val1);
49236 if (!SWIG_IsOK(ecode1)) {
49237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49238 }
49239 arg1 = static_cast< int >(val1);
49240 }
49241 if (obj1) {
49242 ecode2 = SWIG_AsVal_int(obj1, &val2);
49243 if (!SWIG_IsOK(ecode2)) {
49244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49245 }
49246 arg2 = static_cast< int >(val2);
49247 }
49248 {
49249 PyThreadState* __tstate = wxPyBeginAllowThreads();
49250 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49251 wxPyEndAllowThreads(__tstate);
49252 if (PyErr_Occurred()) SWIG_fail;
49253 }
49254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49255 return resultobj;
49256 fail:
49257 return NULL;
49258 }
49259
49260
49261 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49262 PyObject *resultobj = 0;
49263 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49264 void *argp1 = 0 ;
49265 int res1 = 0 ;
49266 PyObject *swig_obj[1] ;
49267
49268 if (!args) SWIG_fail;
49269 swig_obj[0] = args;
49270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49271 if (!SWIG_IsOK(res1)) {
49272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49273 }
49274 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49275 {
49276 PyThreadState* __tstate = wxPyBeginAllowThreads();
49277 delete arg1;
49278
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_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49290 PyObject *resultobj = 0;
49291 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49292 int result;
49293 void *argp1 = 0 ;
49294 int res1 = 0 ;
49295 PyObject *swig_obj[1] ;
49296
49297 if (!args) SWIG_fail;
49298 swig_obj[0] = args;
49299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49300 if (!SWIG_IsOK(res1)) {
49301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49302 }
49303 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49304 {
49305 PyThreadState* __tstate = wxPyBeginAllowThreads();
49306 result = (int)((wxGBPosition const *)arg1)->GetRow();
49307 wxPyEndAllowThreads(__tstate);
49308 if (PyErr_Occurred()) SWIG_fail;
49309 }
49310 resultobj = SWIG_From_int(static_cast< int >(result));
49311 return resultobj;
49312 fail:
49313 return NULL;
49314 }
49315
49316
49317 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49318 PyObject *resultobj = 0;
49319 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49320 int result;
49321 void *argp1 = 0 ;
49322 int res1 = 0 ;
49323 PyObject *swig_obj[1] ;
49324
49325 if (!args) SWIG_fail;
49326 swig_obj[0] = args;
49327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49328 if (!SWIG_IsOK(res1)) {
49329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49330 }
49331 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49332 {
49333 PyThreadState* __tstate = wxPyBeginAllowThreads();
49334 result = (int)((wxGBPosition const *)arg1)->GetCol();
49335 wxPyEndAllowThreads(__tstate);
49336 if (PyErr_Occurred()) SWIG_fail;
49337 }
49338 resultobj = SWIG_From_int(static_cast< int >(result));
49339 return resultobj;
49340 fail:
49341 return NULL;
49342 }
49343
49344
49345 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49346 PyObject *resultobj = 0;
49347 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49348 int arg2 ;
49349 void *argp1 = 0 ;
49350 int res1 = 0 ;
49351 int val2 ;
49352 int ecode2 = 0 ;
49353 PyObject * obj0 = 0 ;
49354 PyObject * obj1 = 0 ;
49355 char * kwnames[] = {
49356 (char *) "self",(char *) "row", NULL
49357 };
49358
49359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49361 if (!SWIG_IsOK(res1)) {
49362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49363 }
49364 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49365 ecode2 = SWIG_AsVal_int(obj1, &val2);
49366 if (!SWIG_IsOK(ecode2)) {
49367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49368 }
49369 arg2 = static_cast< int >(val2);
49370 {
49371 PyThreadState* __tstate = wxPyBeginAllowThreads();
49372 (arg1)->SetRow(arg2);
49373 wxPyEndAllowThreads(__tstate);
49374 if (PyErr_Occurred()) SWIG_fail;
49375 }
49376 resultobj = SWIG_Py_Void();
49377 return resultobj;
49378 fail:
49379 return NULL;
49380 }
49381
49382
49383 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49384 PyObject *resultobj = 0;
49385 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49386 int arg2 ;
49387 void *argp1 = 0 ;
49388 int res1 = 0 ;
49389 int val2 ;
49390 int ecode2 = 0 ;
49391 PyObject * obj0 = 0 ;
49392 PyObject * obj1 = 0 ;
49393 char * kwnames[] = {
49394 (char *) "self",(char *) "col", NULL
49395 };
49396
49397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49399 if (!SWIG_IsOK(res1)) {
49400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49401 }
49402 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49403 ecode2 = SWIG_AsVal_int(obj1, &val2);
49404 if (!SWIG_IsOK(ecode2)) {
49405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49406 }
49407 arg2 = static_cast< int >(val2);
49408 {
49409 PyThreadState* __tstate = wxPyBeginAllowThreads();
49410 (arg1)->SetCol(arg2);
49411 wxPyEndAllowThreads(__tstate);
49412 if (PyErr_Occurred()) SWIG_fail;
49413 }
49414 resultobj = SWIG_Py_Void();
49415 return resultobj;
49416 fail:
49417 return NULL;
49418 }
49419
49420
49421 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49422 PyObject *resultobj = 0;
49423 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49424 PyObject *arg2 = (PyObject *) 0 ;
49425 bool result;
49426 void *argp1 = 0 ;
49427 int res1 = 0 ;
49428 PyObject * obj0 = 0 ;
49429 PyObject * obj1 = 0 ;
49430 char * kwnames[] = {
49431 (char *) "self",(char *) "other", NULL
49432 };
49433
49434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49436 if (!SWIG_IsOK(res1)) {
49437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49438 }
49439 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49440 arg2 = obj1;
49441 {
49442 result = (bool)wxGBPosition___eq__(arg1,arg2);
49443 if (PyErr_Occurred()) SWIG_fail;
49444 }
49445 {
49446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49447 }
49448 return resultobj;
49449 fail:
49450 return NULL;
49451 }
49452
49453
49454 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49455 PyObject *resultobj = 0;
49456 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49457 PyObject *arg2 = (PyObject *) 0 ;
49458 bool result;
49459 void *argp1 = 0 ;
49460 int res1 = 0 ;
49461 PyObject * obj0 = 0 ;
49462 PyObject * obj1 = 0 ;
49463 char * kwnames[] = {
49464 (char *) "self",(char *) "other", NULL
49465 };
49466
49467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49469 if (!SWIG_IsOK(res1)) {
49470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49471 }
49472 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49473 arg2 = obj1;
49474 {
49475 result = (bool)wxGBPosition___ne__(arg1,arg2);
49476 if (PyErr_Occurred()) SWIG_fail;
49477 }
49478 {
49479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49480 }
49481 return resultobj;
49482 fail:
49483 return NULL;
49484 }
49485
49486
49487 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49488 PyObject *resultobj = 0;
49489 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49490 int arg2 = (int) 0 ;
49491 int arg3 = (int) 0 ;
49492 void *argp1 = 0 ;
49493 int res1 = 0 ;
49494 int val2 ;
49495 int ecode2 = 0 ;
49496 int val3 ;
49497 int ecode3 = 0 ;
49498 PyObject * obj0 = 0 ;
49499 PyObject * obj1 = 0 ;
49500 PyObject * obj2 = 0 ;
49501 char * kwnames[] = {
49502 (char *) "self",(char *) "row",(char *) "col", NULL
49503 };
49504
49505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49507 if (!SWIG_IsOK(res1)) {
49508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49509 }
49510 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49511 if (obj1) {
49512 ecode2 = SWIG_AsVal_int(obj1, &val2);
49513 if (!SWIG_IsOK(ecode2)) {
49514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49515 }
49516 arg2 = static_cast< int >(val2);
49517 }
49518 if (obj2) {
49519 ecode3 = SWIG_AsVal_int(obj2, &val3);
49520 if (!SWIG_IsOK(ecode3)) {
49521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49522 }
49523 arg3 = static_cast< int >(val3);
49524 }
49525 {
49526 PyThreadState* __tstate = wxPyBeginAllowThreads();
49527 wxGBPosition_Set(arg1,arg2,arg3);
49528 wxPyEndAllowThreads(__tstate);
49529 if (PyErr_Occurred()) SWIG_fail;
49530 }
49531 resultobj = SWIG_Py_Void();
49532 return resultobj;
49533 fail:
49534 return NULL;
49535 }
49536
49537
49538 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49539 PyObject *resultobj = 0;
49540 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49541 PyObject *result = 0 ;
49542 void *argp1 = 0 ;
49543 int res1 = 0 ;
49544 PyObject *swig_obj[1] ;
49545
49546 if (!args) SWIG_fail;
49547 swig_obj[0] = args;
49548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49549 if (!SWIG_IsOK(res1)) {
49550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49551 }
49552 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49553 {
49554 PyThreadState* __tstate = wxPyBeginAllowThreads();
49555 result = (PyObject *)wxGBPosition_Get(arg1);
49556 wxPyEndAllowThreads(__tstate);
49557 if (PyErr_Occurred()) SWIG_fail;
49558 }
49559 resultobj = result;
49560 return resultobj;
49561 fail:
49562 return NULL;
49563 }
49564
49565
49566 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49567 PyObject *obj;
49568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49569 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49570 return SWIG_Py_Void();
49571 }
49572
49573 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49574 return SWIG_Python_InitShadowInstance(args);
49575 }
49576
49577 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49578 PyObject *resultobj = 0;
49579 int arg1 = (int) 1 ;
49580 int arg2 = (int) 1 ;
49581 wxGBSpan *result = 0 ;
49582 int val1 ;
49583 int ecode1 = 0 ;
49584 int val2 ;
49585 int ecode2 = 0 ;
49586 PyObject * obj0 = 0 ;
49587 PyObject * obj1 = 0 ;
49588 char * kwnames[] = {
49589 (char *) "rowspan",(char *) "colspan", NULL
49590 };
49591
49592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49593 if (obj0) {
49594 ecode1 = SWIG_AsVal_int(obj0, &val1);
49595 if (!SWIG_IsOK(ecode1)) {
49596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49597 }
49598 arg1 = static_cast< int >(val1);
49599 }
49600 if (obj1) {
49601 ecode2 = SWIG_AsVal_int(obj1, &val2);
49602 if (!SWIG_IsOK(ecode2)) {
49603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49604 }
49605 arg2 = static_cast< int >(val2);
49606 }
49607 {
49608 PyThreadState* __tstate = wxPyBeginAllowThreads();
49609 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49610 wxPyEndAllowThreads(__tstate);
49611 if (PyErr_Occurred()) SWIG_fail;
49612 }
49613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49614 return resultobj;
49615 fail:
49616 return NULL;
49617 }
49618
49619
49620 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49621 PyObject *resultobj = 0;
49622 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49623 void *argp1 = 0 ;
49624 int res1 = 0 ;
49625 PyObject *swig_obj[1] ;
49626
49627 if (!args) SWIG_fail;
49628 swig_obj[0] = args;
49629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49630 if (!SWIG_IsOK(res1)) {
49631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49632 }
49633 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49634 {
49635 PyThreadState* __tstate = wxPyBeginAllowThreads();
49636 delete arg1;
49637
49638 wxPyEndAllowThreads(__tstate);
49639 if (PyErr_Occurred()) SWIG_fail;
49640 }
49641 resultobj = SWIG_Py_Void();
49642 return resultobj;
49643 fail:
49644 return NULL;
49645 }
49646
49647
49648 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49649 PyObject *resultobj = 0;
49650 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49651 int result;
49652 void *argp1 = 0 ;
49653 int res1 = 0 ;
49654 PyObject *swig_obj[1] ;
49655
49656 if (!args) SWIG_fail;
49657 swig_obj[0] = args;
49658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49659 if (!SWIG_IsOK(res1)) {
49660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49661 }
49662 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49663 {
49664 PyThreadState* __tstate = wxPyBeginAllowThreads();
49665 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49666 wxPyEndAllowThreads(__tstate);
49667 if (PyErr_Occurred()) SWIG_fail;
49668 }
49669 resultobj = SWIG_From_int(static_cast< int >(result));
49670 return resultobj;
49671 fail:
49672 return NULL;
49673 }
49674
49675
49676 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49677 PyObject *resultobj = 0;
49678 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49679 int result;
49680 void *argp1 = 0 ;
49681 int res1 = 0 ;
49682 PyObject *swig_obj[1] ;
49683
49684 if (!args) SWIG_fail;
49685 swig_obj[0] = args;
49686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49687 if (!SWIG_IsOK(res1)) {
49688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49689 }
49690 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49691 {
49692 PyThreadState* __tstate = wxPyBeginAllowThreads();
49693 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49694 wxPyEndAllowThreads(__tstate);
49695 if (PyErr_Occurred()) SWIG_fail;
49696 }
49697 resultobj = SWIG_From_int(static_cast< int >(result));
49698 return resultobj;
49699 fail:
49700 return NULL;
49701 }
49702
49703
49704 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49705 PyObject *resultobj = 0;
49706 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49707 int arg2 ;
49708 void *argp1 = 0 ;
49709 int res1 = 0 ;
49710 int val2 ;
49711 int ecode2 = 0 ;
49712 PyObject * obj0 = 0 ;
49713 PyObject * obj1 = 0 ;
49714 char * kwnames[] = {
49715 (char *) "self",(char *) "rowspan", NULL
49716 };
49717
49718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49720 if (!SWIG_IsOK(res1)) {
49721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49722 }
49723 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49724 ecode2 = SWIG_AsVal_int(obj1, &val2);
49725 if (!SWIG_IsOK(ecode2)) {
49726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49727 }
49728 arg2 = static_cast< int >(val2);
49729 {
49730 PyThreadState* __tstate = wxPyBeginAllowThreads();
49731 (arg1)->SetRowspan(arg2);
49732 wxPyEndAllowThreads(__tstate);
49733 if (PyErr_Occurred()) SWIG_fail;
49734 }
49735 resultobj = SWIG_Py_Void();
49736 return resultobj;
49737 fail:
49738 return NULL;
49739 }
49740
49741
49742 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49743 PyObject *resultobj = 0;
49744 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49745 int arg2 ;
49746 void *argp1 = 0 ;
49747 int res1 = 0 ;
49748 int val2 ;
49749 int ecode2 = 0 ;
49750 PyObject * obj0 = 0 ;
49751 PyObject * obj1 = 0 ;
49752 char * kwnames[] = {
49753 (char *) "self",(char *) "colspan", NULL
49754 };
49755
49756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49758 if (!SWIG_IsOK(res1)) {
49759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49760 }
49761 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49762 ecode2 = SWIG_AsVal_int(obj1, &val2);
49763 if (!SWIG_IsOK(ecode2)) {
49764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49765 }
49766 arg2 = static_cast< int >(val2);
49767 {
49768 PyThreadState* __tstate = wxPyBeginAllowThreads();
49769 (arg1)->SetColspan(arg2);
49770 wxPyEndAllowThreads(__tstate);
49771 if (PyErr_Occurred()) SWIG_fail;
49772 }
49773 resultobj = SWIG_Py_Void();
49774 return resultobj;
49775 fail:
49776 return NULL;
49777 }
49778
49779
49780 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49781 PyObject *resultobj = 0;
49782 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49783 PyObject *arg2 = (PyObject *) 0 ;
49784 bool result;
49785 void *argp1 = 0 ;
49786 int res1 = 0 ;
49787 PyObject * obj0 = 0 ;
49788 PyObject * obj1 = 0 ;
49789 char * kwnames[] = {
49790 (char *) "self",(char *) "other", NULL
49791 };
49792
49793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49795 if (!SWIG_IsOK(res1)) {
49796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49797 }
49798 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49799 arg2 = obj1;
49800 {
49801 result = (bool)wxGBSpan___eq__(arg1,arg2);
49802 if (PyErr_Occurred()) SWIG_fail;
49803 }
49804 {
49805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49806 }
49807 return resultobj;
49808 fail:
49809 return NULL;
49810 }
49811
49812
49813 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49814 PyObject *resultobj = 0;
49815 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49816 PyObject *arg2 = (PyObject *) 0 ;
49817 bool result;
49818 void *argp1 = 0 ;
49819 int res1 = 0 ;
49820 PyObject * obj0 = 0 ;
49821 PyObject * obj1 = 0 ;
49822 char * kwnames[] = {
49823 (char *) "self",(char *) "other", NULL
49824 };
49825
49826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49828 if (!SWIG_IsOK(res1)) {
49829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49830 }
49831 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49832 arg2 = obj1;
49833 {
49834 result = (bool)wxGBSpan___ne__(arg1,arg2);
49835 if (PyErr_Occurred()) SWIG_fail;
49836 }
49837 {
49838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49839 }
49840 return resultobj;
49841 fail:
49842 return NULL;
49843 }
49844
49845
49846 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49847 PyObject *resultobj = 0;
49848 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49849 int arg2 = (int) 1 ;
49850 int arg3 = (int) 1 ;
49851 void *argp1 = 0 ;
49852 int res1 = 0 ;
49853 int val2 ;
49854 int ecode2 = 0 ;
49855 int val3 ;
49856 int ecode3 = 0 ;
49857 PyObject * obj0 = 0 ;
49858 PyObject * obj1 = 0 ;
49859 PyObject * obj2 = 0 ;
49860 char * kwnames[] = {
49861 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49862 };
49863
49864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49866 if (!SWIG_IsOK(res1)) {
49867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49868 }
49869 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49870 if (obj1) {
49871 ecode2 = SWIG_AsVal_int(obj1, &val2);
49872 if (!SWIG_IsOK(ecode2)) {
49873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49874 }
49875 arg2 = static_cast< int >(val2);
49876 }
49877 if (obj2) {
49878 ecode3 = SWIG_AsVal_int(obj2, &val3);
49879 if (!SWIG_IsOK(ecode3)) {
49880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49881 }
49882 arg3 = static_cast< int >(val3);
49883 }
49884 {
49885 PyThreadState* __tstate = wxPyBeginAllowThreads();
49886 wxGBSpan_Set(arg1,arg2,arg3);
49887 wxPyEndAllowThreads(__tstate);
49888 if (PyErr_Occurred()) SWIG_fail;
49889 }
49890 resultobj = SWIG_Py_Void();
49891 return resultobj;
49892 fail:
49893 return NULL;
49894 }
49895
49896
49897 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49898 PyObject *resultobj = 0;
49899 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49900 PyObject *result = 0 ;
49901 void *argp1 = 0 ;
49902 int res1 = 0 ;
49903 PyObject *swig_obj[1] ;
49904
49905 if (!args) SWIG_fail;
49906 swig_obj[0] = args;
49907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49908 if (!SWIG_IsOK(res1)) {
49909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49910 }
49911 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49912 {
49913 PyThreadState* __tstate = wxPyBeginAllowThreads();
49914 result = (PyObject *)wxGBSpan_Get(arg1);
49915 wxPyEndAllowThreads(__tstate);
49916 if (PyErr_Occurred()) SWIG_fail;
49917 }
49918 resultobj = result;
49919 return resultobj;
49920 fail:
49921 return NULL;
49922 }
49923
49924
49925 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49926 PyObject *obj;
49927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49928 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49929 return SWIG_Py_Void();
49930 }
49931
49932 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49933 return SWIG_Python_InitShadowInstance(args);
49934 }
49935
49936 SWIGINTERN int DefaultSpan_set(PyObject *) {
49937 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49938 return 1;
49939 }
49940
49941
49942 SWIGINTERN PyObject *DefaultSpan_get(void) {
49943 PyObject *pyobj = 0;
49944
49945 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49946 return pyobj;
49947 }
49948
49949
49950 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49951 PyObject *resultobj = 0;
49952 wxGBSizerItem *result = 0 ;
49953
49954 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49955 {
49956 PyThreadState* __tstate = wxPyBeginAllowThreads();
49957 result = (wxGBSizerItem *)new wxGBSizerItem();
49958 wxPyEndAllowThreads(__tstate);
49959 if (PyErr_Occurred()) SWIG_fail;
49960 }
49961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49962 return resultobj;
49963 fail:
49964 return NULL;
49965 }
49966
49967
49968 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49969 PyObject *resultobj = 0;
49970 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
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_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49978 if (!SWIG_IsOK(res1)) {
49979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49980 }
49981 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49982 {
49983 PyThreadState* __tstate = wxPyBeginAllowThreads();
49984 delete arg1;
49985
49986 wxPyEndAllowThreads(__tstate);
49987 if (PyErr_Occurred()) SWIG_fail;
49988 }
49989 resultobj = SWIG_Py_Void();
49990 return resultobj;
49991 fail:
49992 return NULL;
49993 }
49994
49995
49996 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49997 PyObject *resultobj = 0;
49998 wxWindow *arg1 = (wxWindow *) 0 ;
49999 wxGBPosition *arg2 = 0 ;
50000 wxGBSpan *arg3 = 0 ;
50001 int arg4 ;
50002 int arg5 ;
50003 PyObject *arg6 = (PyObject *) NULL ;
50004 wxGBSizerItem *result = 0 ;
50005 void *argp1 = 0 ;
50006 int res1 = 0 ;
50007 wxGBPosition temp2 ;
50008 wxGBSpan temp3 ;
50009 int val4 ;
50010 int ecode4 = 0 ;
50011 int val5 ;
50012 int ecode5 = 0 ;
50013 PyObject * obj0 = 0 ;
50014 PyObject * obj1 = 0 ;
50015 PyObject * obj2 = 0 ;
50016 PyObject * obj3 = 0 ;
50017 PyObject * obj4 = 0 ;
50018 PyObject * obj5 = 0 ;
50019 char * kwnames[] = {
50020 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50021 };
50022
50023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50025 if (!SWIG_IsOK(res1)) {
50026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50027 }
50028 arg1 = reinterpret_cast< wxWindow * >(argp1);
50029 {
50030 arg2 = &temp2;
50031 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50032 }
50033 {
50034 arg3 = &temp3;
50035 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50036 }
50037 ecode4 = SWIG_AsVal_int(obj3, &val4);
50038 if (!SWIG_IsOK(ecode4)) {
50039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50040 }
50041 arg4 = static_cast< int >(val4);
50042 ecode5 = SWIG_AsVal_int(obj4, &val5);
50043 if (!SWIG_IsOK(ecode5)) {
50044 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50045 }
50046 arg5 = static_cast< int >(val5);
50047 if (obj5) {
50048 arg6 = obj5;
50049 }
50050 {
50051 PyThreadState* __tstate = wxPyBeginAllowThreads();
50052 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50053 wxPyEndAllowThreads(__tstate);
50054 if (PyErr_Occurred()) SWIG_fail;
50055 }
50056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50057 return resultobj;
50058 fail:
50059 return NULL;
50060 }
50061
50062
50063 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50064 PyObject *resultobj = 0;
50065 wxSizer *arg1 = (wxSizer *) 0 ;
50066 wxGBPosition *arg2 = 0 ;
50067 wxGBSpan *arg3 = 0 ;
50068 int arg4 ;
50069 int arg5 ;
50070 PyObject *arg6 = (PyObject *) NULL ;
50071 wxGBSizerItem *result = 0 ;
50072 int res1 = 0 ;
50073 wxGBPosition temp2 ;
50074 wxGBSpan temp3 ;
50075 int val4 ;
50076 int ecode4 = 0 ;
50077 int val5 ;
50078 int ecode5 = 0 ;
50079 PyObject * obj0 = 0 ;
50080 PyObject * obj1 = 0 ;
50081 PyObject * obj2 = 0 ;
50082 PyObject * obj3 = 0 ;
50083 PyObject * obj4 = 0 ;
50084 PyObject * obj5 = 0 ;
50085 char * kwnames[] = {
50086 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50087 };
50088
50089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50090 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50091 if (!SWIG_IsOK(res1)) {
50092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50093 }
50094 {
50095 arg2 = &temp2;
50096 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50097 }
50098 {
50099 arg3 = &temp3;
50100 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50101 }
50102 ecode4 = SWIG_AsVal_int(obj3, &val4);
50103 if (!SWIG_IsOK(ecode4)) {
50104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50105 }
50106 arg4 = static_cast< int >(val4);
50107 ecode5 = SWIG_AsVal_int(obj4, &val5);
50108 if (!SWIG_IsOK(ecode5)) {
50109 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50110 }
50111 arg5 = static_cast< int >(val5);
50112 if (obj5) {
50113 arg6 = obj5;
50114 }
50115 {
50116 PyThreadState* __tstate = wxPyBeginAllowThreads();
50117 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50118 wxPyEndAllowThreads(__tstate);
50119 if (PyErr_Occurred()) SWIG_fail;
50120 }
50121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50122 return resultobj;
50123 fail:
50124 return NULL;
50125 }
50126
50127
50128 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50129 PyObject *resultobj = 0;
50130 int arg1 ;
50131 int arg2 ;
50132 wxGBPosition *arg3 = 0 ;
50133 wxGBSpan *arg4 = 0 ;
50134 int arg5 ;
50135 int arg6 ;
50136 PyObject *arg7 = (PyObject *) NULL ;
50137 wxGBSizerItem *result = 0 ;
50138 int val1 ;
50139 int ecode1 = 0 ;
50140 int val2 ;
50141 int ecode2 = 0 ;
50142 wxGBPosition temp3 ;
50143 wxGBSpan temp4 ;
50144 int val5 ;
50145 int ecode5 = 0 ;
50146 int val6 ;
50147 int ecode6 = 0 ;
50148 PyObject * obj0 = 0 ;
50149 PyObject * obj1 = 0 ;
50150 PyObject * obj2 = 0 ;
50151 PyObject * obj3 = 0 ;
50152 PyObject * obj4 = 0 ;
50153 PyObject * obj5 = 0 ;
50154 PyObject * obj6 = 0 ;
50155 char * kwnames[] = {
50156 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50157 };
50158
50159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50160 ecode1 = SWIG_AsVal_int(obj0, &val1);
50161 if (!SWIG_IsOK(ecode1)) {
50162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50163 }
50164 arg1 = static_cast< int >(val1);
50165 ecode2 = SWIG_AsVal_int(obj1, &val2);
50166 if (!SWIG_IsOK(ecode2)) {
50167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50168 }
50169 arg2 = static_cast< int >(val2);
50170 {
50171 arg3 = &temp3;
50172 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50173 }
50174 {
50175 arg4 = &temp4;
50176 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50177 }
50178 ecode5 = SWIG_AsVal_int(obj4, &val5);
50179 if (!SWIG_IsOK(ecode5)) {
50180 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50181 }
50182 arg5 = static_cast< int >(val5);
50183 ecode6 = SWIG_AsVal_int(obj5, &val6);
50184 if (!SWIG_IsOK(ecode6)) {
50185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50186 }
50187 arg6 = static_cast< int >(val6);
50188 if (obj6) {
50189 arg7 = obj6;
50190 }
50191 {
50192 PyThreadState* __tstate = wxPyBeginAllowThreads();
50193 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50194 wxPyEndAllowThreads(__tstate);
50195 if (PyErr_Occurred()) SWIG_fail;
50196 }
50197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50198 return resultobj;
50199 fail:
50200 return NULL;
50201 }
50202
50203
50204 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50205 PyObject *resultobj = 0;
50206 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50207 wxGBPosition result;
50208 void *argp1 = 0 ;
50209 int res1 = 0 ;
50210 PyObject *swig_obj[1] ;
50211
50212 if (!args) SWIG_fail;
50213 swig_obj[0] = args;
50214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50215 if (!SWIG_IsOK(res1)) {
50216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50217 }
50218 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50219 {
50220 PyThreadState* __tstate = wxPyBeginAllowThreads();
50221 result = ((wxGBSizerItem const *)arg1)->GetPos();
50222 wxPyEndAllowThreads(__tstate);
50223 if (PyErr_Occurred()) SWIG_fail;
50224 }
50225 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50226 return resultobj;
50227 fail:
50228 return NULL;
50229 }
50230
50231
50232 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50233 PyObject *resultobj = 0;
50234 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50235 wxGBSpan result;
50236 void *argp1 = 0 ;
50237 int res1 = 0 ;
50238 PyObject *swig_obj[1] ;
50239
50240 if (!args) SWIG_fail;
50241 swig_obj[0] = args;
50242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50243 if (!SWIG_IsOK(res1)) {
50244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50245 }
50246 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50247 {
50248 PyThreadState* __tstate = wxPyBeginAllowThreads();
50249 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50250 wxPyEndAllowThreads(__tstate);
50251 if (PyErr_Occurred()) SWIG_fail;
50252 }
50253 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50254 return resultobj;
50255 fail:
50256 return NULL;
50257 }
50258
50259
50260 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50261 PyObject *resultobj = 0;
50262 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50263 wxGBPosition *arg2 = 0 ;
50264 bool result;
50265 void *argp1 = 0 ;
50266 int res1 = 0 ;
50267 wxGBPosition temp2 ;
50268 PyObject * obj0 = 0 ;
50269 PyObject * obj1 = 0 ;
50270 char * kwnames[] = {
50271 (char *) "self",(char *) "pos", NULL
50272 };
50273
50274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50276 if (!SWIG_IsOK(res1)) {
50277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50278 }
50279 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50280 {
50281 arg2 = &temp2;
50282 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50283 }
50284 {
50285 PyThreadState* __tstate = wxPyBeginAllowThreads();
50286 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50287 wxPyEndAllowThreads(__tstate);
50288 if (PyErr_Occurred()) SWIG_fail;
50289 }
50290 {
50291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50292 }
50293 return resultobj;
50294 fail:
50295 return NULL;
50296 }
50297
50298
50299 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50300 PyObject *resultobj = 0;
50301 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50302 wxGBSpan *arg2 = 0 ;
50303 bool result;
50304 void *argp1 = 0 ;
50305 int res1 = 0 ;
50306 wxGBSpan temp2 ;
50307 PyObject * obj0 = 0 ;
50308 PyObject * obj1 = 0 ;
50309 char * kwnames[] = {
50310 (char *) "self",(char *) "span", NULL
50311 };
50312
50313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50315 if (!SWIG_IsOK(res1)) {
50316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50317 }
50318 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50319 {
50320 arg2 = &temp2;
50321 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50322 }
50323 {
50324 PyThreadState* __tstate = wxPyBeginAllowThreads();
50325 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50326 wxPyEndAllowThreads(__tstate);
50327 if (PyErr_Occurred()) SWIG_fail;
50328 }
50329 {
50330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50331 }
50332 return resultobj;
50333 fail:
50334 return NULL;
50335 }
50336
50337
50338 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50339 PyObject *resultobj = 0;
50340 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50341 wxGBSizerItem *arg2 = 0 ;
50342 bool result;
50343 void *argp1 = 0 ;
50344 int res1 = 0 ;
50345 void *argp2 = 0 ;
50346 int res2 = 0 ;
50347 PyObject * obj0 = 0 ;
50348 PyObject * obj1 = 0 ;
50349 char * kwnames[] = {
50350 (char *) "self",(char *) "other", NULL
50351 };
50352
50353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50355 if (!SWIG_IsOK(res1)) {
50356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50357 }
50358 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50359 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50360 if (!SWIG_IsOK(res2)) {
50361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50362 }
50363 if (!argp2) {
50364 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50365 }
50366 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50367 {
50368 PyThreadState* __tstate = wxPyBeginAllowThreads();
50369 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50370 wxPyEndAllowThreads(__tstate);
50371 if (PyErr_Occurred()) SWIG_fail;
50372 }
50373 {
50374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50375 }
50376 return resultobj;
50377 fail:
50378 return NULL;
50379 }
50380
50381
50382 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50383 PyObject *resultobj = 0;
50384 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50385 wxGBPosition *arg2 = 0 ;
50386 wxGBSpan *arg3 = 0 ;
50387 bool result;
50388 void *argp1 = 0 ;
50389 int res1 = 0 ;
50390 wxGBPosition temp2 ;
50391 wxGBSpan temp3 ;
50392 PyObject * obj0 = 0 ;
50393 PyObject * obj1 = 0 ;
50394 PyObject * obj2 = 0 ;
50395 char * kwnames[] = {
50396 (char *) "self",(char *) "pos",(char *) "span", NULL
50397 };
50398
50399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50401 if (!SWIG_IsOK(res1)) {
50402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50403 }
50404 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50405 {
50406 arg2 = &temp2;
50407 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50408 }
50409 {
50410 arg3 = &temp3;
50411 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50412 }
50413 {
50414 PyThreadState* __tstate = wxPyBeginAllowThreads();
50415 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50416 wxPyEndAllowThreads(__tstate);
50417 if (PyErr_Occurred()) SWIG_fail;
50418 }
50419 {
50420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50421 }
50422 return resultobj;
50423 fail:
50424 return NULL;
50425 }
50426
50427
50428 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50429 PyObject *resultobj = 0;
50430 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50431 wxGBPosition result;
50432 void *argp1 = 0 ;
50433 int res1 = 0 ;
50434 PyObject *swig_obj[1] ;
50435
50436 if (!args) SWIG_fail;
50437 swig_obj[0] = args;
50438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50439 if (!SWIG_IsOK(res1)) {
50440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50441 }
50442 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50443 {
50444 PyThreadState* __tstate = wxPyBeginAllowThreads();
50445 result = wxGBSizerItem_GetEndPos(arg1);
50446 wxPyEndAllowThreads(__tstate);
50447 if (PyErr_Occurred()) SWIG_fail;
50448 }
50449 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50450 return resultobj;
50451 fail:
50452 return NULL;
50453 }
50454
50455
50456 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50457 PyObject *resultobj = 0;
50458 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50459 wxGridBagSizer *result = 0 ;
50460 void *argp1 = 0 ;
50461 int res1 = 0 ;
50462 PyObject *swig_obj[1] ;
50463
50464 if (!args) SWIG_fail;
50465 swig_obj[0] = args;
50466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50467 if (!SWIG_IsOK(res1)) {
50468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50469 }
50470 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50471 {
50472 PyThreadState* __tstate = wxPyBeginAllowThreads();
50473 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50474 wxPyEndAllowThreads(__tstate);
50475 if (PyErr_Occurred()) SWIG_fail;
50476 }
50477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50478 return resultobj;
50479 fail:
50480 return NULL;
50481 }
50482
50483
50484 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50485 PyObject *resultobj = 0;
50486 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50487 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50488 void *argp1 = 0 ;
50489 int res1 = 0 ;
50490 void *argp2 = 0 ;
50491 int res2 = 0 ;
50492 PyObject * obj0 = 0 ;
50493 PyObject * obj1 = 0 ;
50494 char * kwnames[] = {
50495 (char *) "self",(char *) "sizer", NULL
50496 };
50497
50498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50500 if (!SWIG_IsOK(res1)) {
50501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50502 }
50503 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50504 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50505 if (!SWIG_IsOK(res2)) {
50506 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50507 }
50508 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50509 {
50510 PyThreadState* __tstate = wxPyBeginAllowThreads();
50511 (arg1)->SetGBSizer(arg2);
50512 wxPyEndAllowThreads(__tstate);
50513 if (PyErr_Occurred()) SWIG_fail;
50514 }
50515 resultobj = SWIG_Py_Void();
50516 return resultobj;
50517 fail:
50518 return NULL;
50519 }
50520
50521
50522 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50523 PyObject *obj;
50524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50525 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50526 return SWIG_Py_Void();
50527 }
50528
50529 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50530 return SWIG_Python_InitShadowInstance(args);
50531 }
50532
50533 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50534 PyObject *resultobj = 0;
50535 int arg1 = (int) 0 ;
50536 int arg2 = (int) 0 ;
50537 wxGridBagSizer *result = 0 ;
50538 int val1 ;
50539 int ecode1 = 0 ;
50540 int val2 ;
50541 int ecode2 = 0 ;
50542 PyObject * obj0 = 0 ;
50543 PyObject * obj1 = 0 ;
50544 char * kwnames[] = {
50545 (char *) "vgap",(char *) "hgap", NULL
50546 };
50547
50548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50549 if (obj0) {
50550 ecode1 = SWIG_AsVal_int(obj0, &val1);
50551 if (!SWIG_IsOK(ecode1)) {
50552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50553 }
50554 arg1 = static_cast< int >(val1);
50555 }
50556 if (obj1) {
50557 ecode2 = SWIG_AsVal_int(obj1, &val2);
50558 if (!SWIG_IsOK(ecode2)) {
50559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50560 }
50561 arg2 = static_cast< int >(val2);
50562 }
50563 {
50564 PyThreadState* __tstate = wxPyBeginAllowThreads();
50565 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50566 wxPyEndAllowThreads(__tstate);
50567 if (PyErr_Occurred()) SWIG_fail;
50568 }
50569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50570 return resultobj;
50571 fail:
50572 return NULL;
50573 }
50574
50575
50576 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50577 PyObject *resultobj = 0;
50578 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50579 PyObject *arg2 = (PyObject *) 0 ;
50580 wxGBPosition *arg3 = 0 ;
50581 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50582 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50583 int arg5 = (int) 0 ;
50584 int arg6 = (int) 0 ;
50585 PyObject *arg7 = (PyObject *) NULL ;
50586 wxGBSizerItem *result = 0 ;
50587 void *argp1 = 0 ;
50588 int res1 = 0 ;
50589 wxGBPosition temp3 ;
50590 wxGBSpan temp4 ;
50591 int val5 ;
50592 int ecode5 = 0 ;
50593 int val6 ;
50594 int ecode6 = 0 ;
50595 PyObject * obj0 = 0 ;
50596 PyObject * obj1 = 0 ;
50597 PyObject * obj2 = 0 ;
50598 PyObject * obj3 = 0 ;
50599 PyObject * obj4 = 0 ;
50600 PyObject * obj5 = 0 ;
50601 PyObject * obj6 = 0 ;
50602 char * kwnames[] = {
50603 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50604 };
50605
50606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50608 if (!SWIG_IsOK(res1)) {
50609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50610 }
50611 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50612 arg2 = obj1;
50613 {
50614 arg3 = &temp3;
50615 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50616 }
50617 if (obj3) {
50618 {
50619 arg4 = &temp4;
50620 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50621 }
50622 }
50623 if (obj4) {
50624 ecode5 = SWIG_AsVal_int(obj4, &val5);
50625 if (!SWIG_IsOK(ecode5)) {
50626 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50627 }
50628 arg5 = static_cast< int >(val5);
50629 }
50630 if (obj5) {
50631 ecode6 = SWIG_AsVal_int(obj5, &val6);
50632 if (!SWIG_IsOK(ecode6)) {
50633 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50634 }
50635 arg6 = static_cast< int >(val6);
50636 }
50637 if (obj6) {
50638 arg7 = obj6;
50639 }
50640 {
50641 PyThreadState* __tstate = wxPyBeginAllowThreads();
50642 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50643 wxPyEndAllowThreads(__tstate);
50644 if (PyErr_Occurred()) SWIG_fail;
50645 }
50646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50647 return resultobj;
50648 fail:
50649 return NULL;
50650 }
50651
50652
50653 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50654 PyObject *resultobj = 0;
50655 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50656 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50657 wxGBSizerItem *result = 0 ;
50658 void *argp1 = 0 ;
50659 int res1 = 0 ;
50660 int res2 = 0 ;
50661 PyObject * obj0 = 0 ;
50662 PyObject * obj1 = 0 ;
50663 char * kwnames[] = {
50664 (char *) "self",(char *) "item", NULL
50665 };
50666
50667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50669 if (!SWIG_IsOK(res1)) {
50670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50671 }
50672 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50673 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50674 if (!SWIG_IsOK(res2)) {
50675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50676 }
50677 {
50678 PyThreadState* __tstate = wxPyBeginAllowThreads();
50679 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50680 wxPyEndAllowThreads(__tstate);
50681 if (PyErr_Occurred()) SWIG_fail;
50682 }
50683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50684 return resultobj;
50685 fail:
50686 return NULL;
50687 }
50688
50689
50690 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50691 PyObject *resultobj = 0;
50692 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50693 int arg2 ;
50694 int arg3 ;
50695 wxSize result;
50696 void *argp1 = 0 ;
50697 int res1 = 0 ;
50698 int val2 ;
50699 int ecode2 = 0 ;
50700 int val3 ;
50701 int ecode3 = 0 ;
50702 PyObject * obj0 = 0 ;
50703 PyObject * obj1 = 0 ;
50704 PyObject * obj2 = 0 ;
50705 char * kwnames[] = {
50706 (char *) "self",(char *) "row",(char *) "col", NULL
50707 };
50708
50709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50711 if (!SWIG_IsOK(res1)) {
50712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50713 }
50714 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50715 ecode2 = SWIG_AsVal_int(obj1, &val2);
50716 if (!SWIG_IsOK(ecode2)) {
50717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50718 }
50719 arg2 = static_cast< int >(val2);
50720 ecode3 = SWIG_AsVal_int(obj2, &val3);
50721 if (!SWIG_IsOK(ecode3)) {
50722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50723 }
50724 arg3 = static_cast< int >(val3);
50725 {
50726 PyThreadState* __tstate = wxPyBeginAllowThreads();
50727 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50728 wxPyEndAllowThreads(__tstate);
50729 if (PyErr_Occurred()) SWIG_fail;
50730 }
50731 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50732 return resultobj;
50733 fail:
50734 return NULL;
50735 }
50736
50737
50738 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50739 PyObject *resultobj = 0;
50740 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50741 wxSize result;
50742 void *argp1 = 0 ;
50743 int res1 = 0 ;
50744 PyObject *swig_obj[1] ;
50745
50746 if (!args) SWIG_fail;
50747 swig_obj[0] = args;
50748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50749 if (!SWIG_IsOK(res1)) {
50750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50751 }
50752 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50753 {
50754 PyThreadState* __tstate = wxPyBeginAllowThreads();
50755 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50756 wxPyEndAllowThreads(__tstate);
50757 if (PyErr_Occurred()) SWIG_fail;
50758 }
50759 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50767 PyObject *resultobj = 0;
50768 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50769 wxSize *arg2 = 0 ;
50770 void *argp1 = 0 ;
50771 int res1 = 0 ;
50772 wxSize temp2 ;
50773 PyObject * obj0 = 0 ;
50774 PyObject * obj1 = 0 ;
50775 char * kwnames[] = {
50776 (char *) "self",(char *) "sz", NULL
50777 };
50778
50779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50781 if (!SWIG_IsOK(res1)) {
50782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50783 }
50784 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50785 {
50786 arg2 = &temp2;
50787 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50788 }
50789 {
50790 PyThreadState* __tstate = wxPyBeginAllowThreads();
50791 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50792 wxPyEndAllowThreads(__tstate);
50793 if (PyErr_Occurred()) SWIG_fail;
50794 }
50795 resultobj = SWIG_Py_Void();
50796 return resultobj;
50797 fail:
50798 return NULL;
50799 }
50800
50801
50802 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50803 PyObject *resultobj = 0;
50804 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50805 wxWindow *arg2 = (wxWindow *) 0 ;
50806 wxGBPosition result;
50807 void *argp1 = 0 ;
50808 int res1 = 0 ;
50809 void *argp2 = 0 ;
50810 int res2 = 0 ;
50811
50812 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50814 if (!SWIG_IsOK(res1)) {
50815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50816 }
50817 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50818 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50819 if (!SWIG_IsOK(res2)) {
50820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50821 }
50822 arg2 = reinterpret_cast< wxWindow * >(argp2);
50823 {
50824 PyThreadState* __tstate = wxPyBeginAllowThreads();
50825 result = (arg1)->GetItemPosition(arg2);
50826 wxPyEndAllowThreads(__tstate);
50827 if (PyErr_Occurred()) SWIG_fail;
50828 }
50829 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50830 return resultobj;
50831 fail:
50832 return NULL;
50833 }
50834
50835
50836 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50837 PyObject *resultobj = 0;
50838 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50839 wxSizer *arg2 = (wxSizer *) 0 ;
50840 wxGBPosition result;
50841 void *argp1 = 0 ;
50842 int res1 = 0 ;
50843 void *argp2 = 0 ;
50844 int res2 = 0 ;
50845
50846 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50848 if (!SWIG_IsOK(res1)) {
50849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50850 }
50851 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50852 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50853 if (!SWIG_IsOK(res2)) {
50854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50855 }
50856 arg2 = reinterpret_cast< wxSizer * >(argp2);
50857 {
50858 PyThreadState* __tstate = wxPyBeginAllowThreads();
50859 result = (arg1)->GetItemPosition(arg2);
50860 wxPyEndAllowThreads(__tstate);
50861 if (PyErr_Occurred()) SWIG_fail;
50862 }
50863 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50864 return resultobj;
50865 fail:
50866 return NULL;
50867 }
50868
50869
50870 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50871 PyObject *resultobj = 0;
50872 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50873 size_t arg2 ;
50874 wxGBPosition result;
50875 void *argp1 = 0 ;
50876 int res1 = 0 ;
50877 size_t val2 ;
50878 int ecode2 = 0 ;
50879
50880 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50882 if (!SWIG_IsOK(res1)) {
50883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50884 }
50885 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50886 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50887 if (!SWIG_IsOK(ecode2)) {
50888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50889 }
50890 arg2 = static_cast< size_t >(val2);
50891 {
50892 PyThreadState* __tstate = wxPyBeginAllowThreads();
50893 result = (arg1)->GetItemPosition(arg2);
50894 wxPyEndAllowThreads(__tstate);
50895 if (PyErr_Occurred()) SWIG_fail;
50896 }
50897 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50898 return resultobj;
50899 fail:
50900 return NULL;
50901 }
50902
50903
50904 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50905 int argc;
50906 PyObject *argv[3];
50907
50908 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50909 --argc;
50910 if (argc == 2) {
50911 int _v = 0;
50912 {
50913 void *vptr = 0;
50914 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50915 _v = SWIG_CheckState(res);
50916 }
50917 if (!_v) goto check_1;
50918 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50919 }
50920 check_1:
50921
50922 if (argc == 2) {
50923 int _v = 0;
50924 {
50925 void *vptr = 0;
50926 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50927 _v = SWIG_CheckState(res);
50928 }
50929 if (!_v) goto check_2;
50930 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50931 }
50932 check_2:
50933
50934 if (argc == 2) {
50935 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50936 }
50937
50938 fail:
50939 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50940 return NULL;
50941 }
50942
50943
50944 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50945 PyObject *resultobj = 0;
50946 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50947 wxWindow *arg2 = (wxWindow *) 0 ;
50948 wxGBPosition *arg3 = 0 ;
50949 bool result;
50950 void *argp1 = 0 ;
50951 int res1 = 0 ;
50952 void *argp2 = 0 ;
50953 int res2 = 0 ;
50954 wxGBPosition temp3 ;
50955
50956 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50958 if (!SWIG_IsOK(res1)) {
50959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50960 }
50961 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50962 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50963 if (!SWIG_IsOK(res2)) {
50964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50965 }
50966 arg2 = reinterpret_cast< wxWindow * >(argp2);
50967 {
50968 arg3 = &temp3;
50969 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50970 }
50971 {
50972 PyThreadState* __tstate = wxPyBeginAllowThreads();
50973 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50974 wxPyEndAllowThreads(__tstate);
50975 if (PyErr_Occurred()) SWIG_fail;
50976 }
50977 {
50978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50979 }
50980 return resultobj;
50981 fail:
50982 return NULL;
50983 }
50984
50985
50986 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50987 PyObject *resultobj = 0;
50988 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50989 wxSizer *arg2 = (wxSizer *) 0 ;
50990 wxGBPosition *arg3 = 0 ;
50991 bool result;
50992 void *argp1 = 0 ;
50993 int res1 = 0 ;
50994 void *argp2 = 0 ;
50995 int res2 = 0 ;
50996 wxGBPosition temp3 ;
50997
50998 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51000 if (!SWIG_IsOK(res1)) {
51001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51002 }
51003 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51004 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51005 if (!SWIG_IsOK(res2)) {
51006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51007 }
51008 arg2 = reinterpret_cast< wxSizer * >(argp2);
51009 {
51010 arg3 = &temp3;
51011 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51012 }
51013 {
51014 PyThreadState* __tstate = wxPyBeginAllowThreads();
51015 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51016 wxPyEndAllowThreads(__tstate);
51017 if (PyErr_Occurred()) SWIG_fail;
51018 }
51019 {
51020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51021 }
51022 return resultobj;
51023 fail:
51024 return NULL;
51025 }
51026
51027
51028 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51029 PyObject *resultobj = 0;
51030 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51031 size_t arg2 ;
51032 wxGBPosition *arg3 = 0 ;
51033 bool result;
51034 void *argp1 = 0 ;
51035 int res1 = 0 ;
51036 size_t val2 ;
51037 int ecode2 = 0 ;
51038 wxGBPosition temp3 ;
51039
51040 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51042 if (!SWIG_IsOK(res1)) {
51043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51044 }
51045 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51046 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51047 if (!SWIG_IsOK(ecode2)) {
51048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51049 }
51050 arg2 = static_cast< size_t >(val2);
51051 {
51052 arg3 = &temp3;
51053 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51054 }
51055 {
51056 PyThreadState* __tstate = wxPyBeginAllowThreads();
51057 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51058 wxPyEndAllowThreads(__tstate);
51059 if (PyErr_Occurred()) SWIG_fail;
51060 }
51061 {
51062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51063 }
51064 return resultobj;
51065 fail:
51066 return NULL;
51067 }
51068
51069
51070 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51071 int argc;
51072 PyObject *argv[4];
51073
51074 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51075 --argc;
51076 if (argc == 3) {
51077 int _v = 0;
51078 {
51079 void *vptr = 0;
51080 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51081 _v = SWIG_CheckState(res);
51082 }
51083 if (!_v) goto check_1;
51084 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51085 }
51086 check_1:
51087
51088 if (argc == 3) {
51089 int _v = 0;
51090 {
51091 void *vptr = 0;
51092 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51093 _v = SWIG_CheckState(res);
51094 }
51095 if (!_v) goto check_2;
51096 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51097 }
51098 check_2:
51099
51100 if (argc == 3) {
51101 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51102 }
51103
51104 fail:
51105 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51106 return NULL;
51107 }
51108
51109
51110 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51111 PyObject *resultobj = 0;
51112 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51113 wxWindow *arg2 = (wxWindow *) 0 ;
51114 wxGBSpan result;
51115 void *argp1 = 0 ;
51116 int res1 = 0 ;
51117 void *argp2 = 0 ;
51118 int res2 = 0 ;
51119
51120 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51122 if (!SWIG_IsOK(res1)) {
51123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51124 }
51125 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51126 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51127 if (!SWIG_IsOK(res2)) {
51128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51129 }
51130 arg2 = reinterpret_cast< wxWindow * >(argp2);
51131 {
51132 PyThreadState* __tstate = wxPyBeginAllowThreads();
51133 result = (arg1)->GetItemSpan(arg2);
51134 wxPyEndAllowThreads(__tstate);
51135 if (PyErr_Occurred()) SWIG_fail;
51136 }
51137 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51138 return resultobj;
51139 fail:
51140 return NULL;
51141 }
51142
51143
51144 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51145 PyObject *resultobj = 0;
51146 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51147 wxSizer *arg2 = (wxSizer *) 0 ;
51148 wxGBSpan result;
51149 void *argp1 = 0 ;
51150 int res1 = 0 ;
51151 void *argp2 = 0 ;
51152 int res2 = 0 ;
51153
51154 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51156 if (!SWIG_IsOK(res1)) {
51157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51158 }
51159 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51160 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51161 if (!SWIG_IsOK(res2)) {
51162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51163 }
51164 arg2 = reinterpret_cast< wxSizer * >(argp2);
51165 {
51166 PyThreadState* __tstate = wxPyBeginAllowThreads();
51167 result = (arg1)->GetItemSpan(arg2);
51168 wxPyEndAllowThreads(__tstate);
51169 if (PyErr_Occurred()) SWIG_fail;
51170 }
51171 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51172 return resultobj;
51173 fail:
51174 return NULL;
51175 }
51176
51177
51178 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51179 PyObject *resultobj = 0;
51180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51181 size_t arg2 ;
51182 wxGBSpan result;
51183 void *argp1 = 0 ;
51184 int res1 = 0 ;
51185 size_t val2 ;
51186 int ecode2 = 0 ;
51187
51188 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51190 if (!SWIG_IsOK(res1)) {
51191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51192 }
51193 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51194 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51195 if (!SWIG_IsOK(ecode2)) {
51196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51197 }
51198 arg2 = static_cast< size_t >(val2);
51199 {
51200 PyThreadState* __tstate = wxPyBeginAllowThreads();
51201 result = (arg1)->GetItemSpan(arg2);
51202 wxPyEndAllowThreads(__tstate);
51203 if (PyErr_Occurred()) SWIG_fail;
51204 }
51205 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51206 return resultobj;
51207 fail:
51208 return NULL;
51209 }
51210
51211
51212 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51213 int argc;
51214 PyObject *argv[3];
51215
51216 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51217 --argc;
51218 if (argc == 2) {
51219 int _v = 0;
51220 {
51221 void *vptr = 0;
51222 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51223 _v = SWIG_CheckState(res);
51224 }
51225 if (!_v) goto check_1;
51226 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51227 }
51228 check_1:
51229
51230 if (argc == 2) {
51231 int _v = 0;
51232 {
51233 void *vptr = 0;
51234 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51235 _v = SWIG_CheckState(res);
51236 }
51237 if (!_v) goto check_2;
51238 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51239 }
51240 check_2:
51241
51242 if (argc == 2) {
51243 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51244 }
51245
51246 fail:
51247 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51248 return NULL;
51249 }
51250
51251
51252 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51253 PyObject *resultobj = 0;
51254 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51255 wxWindow *arg2 = (wxWindow *) 0 ;
51256 wxGBSpan *arg3 = 0 ;
51257 bool result;
51258 void *argp1 = 0 ;
51259 int res1 = 0 ;
51260 void *argp2 = 0 ;
51261 int res2 = 0 ;
51262 wxGBSpan temp3 ;
51263
51264 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51266 if (!SWIG_IsOK(res1)) {
51267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51268 }
51269 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51270 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51271 if (!SWIG_IsOK(res2)) {
51272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51273 }
51274 arg2 = reinterpret_cast< wxWindow * >(argp2);
51275 {
51276 arg3 = &temp3;
51277 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51278 }
51279 {
51280 PyThreadState* __tstate = wxPyBeginAllowThreads();
51281 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51282 wxPyEndAllowThreads(__tstate);
51283 if (PyErr_Occurred()) SWIG_fail;
51284 }
51285 {
51286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51287 }
51288 return resultobj;
51289 fail:
51290 return NULL;
51291 }
51292
51293
51294 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51295 PyObject *resultobj = 0;
51296 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51297 wxSizer *arg2 = (wxSizer *) 0 ;
51298 wxGBSpan *arg3 = 0 ;
51299 bool result;
51300 void *argp1 = 0 ;
51301 int res1 = 0 ;
51302 void *argp2 = 0 ;
51303 int res2 = 0 ;
51304 wxGBSpan temp3 ;
51305
51306 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51308 if (!SWIG_IsOK(res1)) {
51309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51310 }
51311 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51312 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51313 if (!SWIG_IsOK(res2)) {
51314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51315 }
51316 arg2 = reinterpret_cast< wxSizer * >(argp2);
51317 {
51318 arg3 = &temp3;
51319 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51320 }
51321 {
51322 PyThreadState* __tstate = wxPyBeginAllowThreads();
51323 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51324 wxPyEndAllowThreads(__tstate);
51325 if (PyErr_Occurred()) SWIG_fail;
51326 }
51327 {
51328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51329 }
51330 return resultobj;
51331 fail:
51332 return NULL;
51333 }
51334
51335
51336 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51337 PyObject *resultobj = 0;
51338 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51339 size_t arg2 ;
51340 wxGBSpan *arg3 = 0 ;
51341 bool result;
51342 void *argp1 = 0 ;
51343 int res1 = 0 ;
51344 size_t val2 ;
51345 int ecode2 = 0 ;
51346 wxGBSpan temp3 ;
51347
51348 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51350 if (!SWIG_IsOK(res1)) {
51351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51352 }
51353 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51354 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51355 if (!SWIG_IsOK(ecode2)) {
51356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51357 }
51358 arg2 = static_cast< size_t >(val2);
51359 {
51360 arg3 = &temp3;
51361 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51362 }
51363 {
51364 PyThreadState* __tstate = wxPyBeginAllowThreads();
51365 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51366 wxPyEndAllowThreads(__tstate);
51367 if (PyErr_Occurred()) SWIG_fail;
51368 }
51369 {
51370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51371 }
51372 return resultobj;
51373 fail:
51374 return NULL;
51375 }
51376
51377
51378 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51379 int argc;
51380 PyObject *argv[4];
51381
51382 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51383 --argc;
51384 if (argc == 3) {
51385 int _v = 0;
51386 {
51387 void *vptr = 0;
51388 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51389 _v = SWIG_CheckState(res);
51390 }
51391 if (!_v) goto check_1;
51392 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51393 }
51394 check_1:
51395
51396 if (argc == 3) {
51397 int _v = 0;
51398 {
51399 void *vptr = 0;
51400 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51401 _v = SWIG_CheckState(res);
51402 }
51403 if (!_v) goto check_2;
51404 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51405 }
51406 check_2:
51407
51408 if (argc == 3) {
51409 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51410 }
51411
51412 fail:
51413 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51414 return NULL;
51415 }
51416
51417
51418 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51419 PyObject *resultobj = 0;
51420 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51421 wxWindow *arg2 = (wxWindow *) 0 ;
51422 wxGBSizerItem *result = 0 ;
51423 void *argp1 = 0 ;
51424 int res1 = 0 ;
51425 void *argp2 = 0 ;
51426 int res2 = 0 ;
51427
51428 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51430 if (!SWIG_IsOK(res1)) {
51431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51432 }
51433 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51434 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51435 if (!SWIG_IsOK(res2)) {
51436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51437 }
51438 arg2 = reinterpret_cast< wxWindow * >(argp2);
51439 {
51440 PyThreadState* __tstate = wxPyBeginAllowThreads();
51441 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51442 wxPyEndAllowThreads(__tstate);
51443 if (PyErr_Occurred()) SWIG_fail;
51444 }
51445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51446 return resultobj;
51447 fail:
51448 return NULL;
51449 }
51450
51451
51452 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51453 PyObject *resultobj = 0;
51454 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51455 wxSizer *arg2 = (wxSizer *) 0 ;
51456 wxGBSizerItem *result = 0 ;
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_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51466 }
51467 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51468 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51469 if (!SWIG_IsOK(res2)) {
51470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51471 }
51472 arg2 = reinterpret_cast< wxSizer * >(argp2);
51473 {
51474 PyThreadState* __tstate = wxPyBeginAllowThreads();
51475 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51476 wxPyEndAllowThreads(__tstate);
51477 if (PyErr_Occurred()) SWIG_fail;
51478 }
51479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51480 return resultobj;
51481 fail:
51482 return NULL;
51483 }
51484
51485
51486 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51487 int argc;
51488 PyObject *argv[3];
51489
51490 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51491 --argc;
51492 if (argc == 2) {
51493 int _v = 0;
51494 {
51495 void *vptr = 0;
51496 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51497 _v = SWIG_CheckState(res);
51498 }
51499 if (!_v) goto check_1;
51500 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51501 }
51502 check_1:
51503
51504 if (argc == 2) {
51505 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51506 }
51507
51508 fail:
51509 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51510 return NULL;
51511 }
51512
51513
51514 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51515 PyObject *resultobj = 0;
51516 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51517 wxGBPosition *arg2 = 0 ;
51518 wxGBSizerItem *result = 0 ;
51519 void *argp1 = 0 ;
51520 int res1 = 0 ;
51521 wxGBPosition temp2 ;
51522 PyObject * obj0 = 0 ;
51523 PyObject * obj1 = 0 ;
51524 char * kwnames[] = {
51525 (char *) "self",(char *) "pos", NULL
51526 };
51527
51528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51530 if (!SWIG_IsOK(res1)) {
51531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51532 }
51533 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51534 {
51535 arg2 = &temp2;
51536 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51537 }
51538 {
51539 PyThreadState* __tstate = wxPyBeginAllowThreads();
51540 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51541 wxPyEndAllowThreads(__tstate);
51542 if (PyErr_Occurred()) SWIG_fail;
51543 }
51544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51545 return resultobj;
51546 fail:
51547 return NULL;
51548 }
51549
51550
51551 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51552 PyObject *resultobj = 0;
51553 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51554 wxPoint *arg2 = 0 ;
51555 wxGBSizerItem *result = 0 ;
51556 void *argp1 = 0 ;
51557 int res1 = 0 ;
51558 wxPoint temp2 ;
51559 PyObject * obj0 = 0 ;
51560 PyObject * obj1 = 0 ;
51561 char * kwnames[] = {
51562 (char *) "self",(char *) "pt", NULL
51563 };
51564
51565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51567 if (!SWIG_IsOK(res1)) {
51568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51569 }
51570 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51571 {
51572 arg2 = &temp2;
51573 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51574 }
51575 {
51576 PyThreadState* __tstate = wxPyBeginAllowThreads();
51577 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51578 wxPyEndAllowThreads(__tstate);
51579 if (PyErr_Occurred()) SWIG_fail;
51580 }
51581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51582 return resultobj;
51583 fail:
51584 return NULL;
51585 }
51586
51587
51588 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51589 PyObject *resultobj = 0;
51590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51591 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51592 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51593 bool result;
51594 void *argp1 = 0 ;
51595 int res1 = 0 ;
51596 void *argp2 = 0 ;
51597 int res2 = 0 ;
51598 void *argp3 = 0 ;
51599 int res3 = 0 ;
51600 PyObject * obj0 = 0 ;
51601 PyObject * obj1 = 0 ;
51602 PyObject * obj2 = 0 ;
51603 char * kwnames[] = {
51604 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51605 };
51606
51607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51609 if (!SWIG_IsOK(res1)) {
51610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51611 }
51612 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51614 if (!SWIG_IsOK(res2)) {
51615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51616 }
51617 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51618 if (obj2) {
51619 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51620 if (!SWIG_IsOK(res3)) {
51621 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51622 }
51623 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51624 }
51625 {
51626 PyThreadState* __tstate = wxPyBeginAllowThreads();
51627 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51628 wxPyEndAllowThreads(__tstate);
51629 if (PyErr_Occurred()) SWIG_fail;
51630 }
51631 {
51632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51633 }
51634 return resultobj;
51635 fail:
51636 return NULL;
51637 }
51638
51639
51640 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51641 PyObject *resultobj = 0;
51642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51643 wxGBPosition *arg2 = 0 ;
51644 wxGBSpan *arg3 = 0 ;
51645 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51646 bool result;
51647 void *argp1 = 0 ;
51648 int res1 = 0 ;
51649 wxGBPosition temp2 ;
51650 wxGBSpan temp3 ;
51651 void *argp4 = 0 ;
51652 int res4 = 0 ;
51653 PyObject * obj0 = 0 ;
51654 PyObject * obj1 = 0 ;
51655 PyObject * obj2 = 0 ;
51656 PyObject * obj3 = 0 ;
51657 char * kwnames[] = {
51658 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51659 };
51660
51661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51663 if (!SWIG_IsOK(res1)) {
51664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51665 }
51666 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51667 {
51668 arg2 = &temp2;
51669 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51670 }
51671 {
51672 arg3 = &temp3;
51673 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51674 }
51675 if (obj3) {
51676 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51677 if (!SWIG_IsOK(res4)) {
51678 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51679 }
51680 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51681 }
51682 {
51683 PyThreadState* __tstate = wxPyBeginAllowThreads();
51684 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51685 wxPyEndAllowThreads(__tstate);
51686 if (PyErr_Occurred()) SWIG_fail;
51687 }
51688 {
51689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51690 }
51691 return resultobj;
51692 fail:
51693 return NULL;
51694 }
51695
51696
51697 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51698 PyObject *obj;
51699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51700 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51701 return SWIG_Py_Void();
51702 }
51703
51704 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51705 return SWIG_Python_InitShadowInstance(args);
51706 }
51707
51708 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51709 PyObject *resultobj = 0;
51710 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51711 wxRelationship arg2 ;
51712 wxWindow *arg3 = (wxWindow *) 0 ;
51713 wxEdge arg4 ;
51714 int arg5 = (int) 0 ;
51715 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51716 void *argp1 = 0 ;
51717 int res1 = 0 ;
51718 int val2 ;
51719 int ecode2 = 0 ;
51720 void *argp3 = 0 ;
51721 int res3 = 0 ;
51722 int val4 ;
51723 int ecode4 = 0 ;
51724 int val5 ;
51725 int ecode5 = 0 ;
51726 int val6 ;
51727 int ecode6 = 0 ;
51728 PyObject * obj0 = 0 ;
51729 PyObject * obj1 = 0 ;
51730 PyObject * obj2 = 0 ;
51731 PyObject * obj3 = 0 ;
51732 PyObject * obj4 = 0 ;
51733 PyObject * obj5 = 0 ;
51734 char * kwnames[] = {
51735 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51736 };
51737
51738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51740 if (!SWIG_IsOK(res1)) {
51741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51742 }
51743 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51744 ecode2 = SWIG_AsVal_int(obj1, &val2);
51745 if (!SWIG_IsOK(ecode2)) {
51746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51747 }
51748 arg2 = static_cast< wxRelationship >(val2);
51749 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51750 if (!SWIG_IsOK(res3)) {
51751 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51752 }
51753 arg3 = reinterpret_cast< wxWindow * >(argp3);
51754 ecode4 = SWIG_AsVal_int(obj3, &val4);
51755 if (!SWIG_IsOK(ecode4)) {
51756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51757 }
51758 arg4 = static_cast< wxEdge >(val4);
51759 if (obj4) {
51760 ecode5 = SWIG_AsVal_int(obj4, &val5);
51761 if (!SWIG_IsOK(ecode5)) {
51762 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51763 }
51764 arg5 = static_cast< int >(val5);
51765 }
51766 if (obj5) {
51767 ecode6 = SWIG_AsVal_int(obj5, &val6);
51768 if (!SWIG_IsOK(ecode6)) {
51769 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51770 }
51771 arg6 = static_cast< int >(val6);
51772 }
51773 {
51774 PyThreadState* __tstate = wxPyBeginAllowThreads();
51775 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51776 wxPyEndAllowThreads(__tstate);
51777 if (PyErr_Occurred()) SWIG_fail;
51778 }
51779 resultobj = SWIG_Py_Void();
51780 return resultobj;
51781 fail:
51782 return NULL;
51783 }
51784
51785
51786 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51787 PyObject *resultobj = 0;
51788 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51789 wxWindow *arg2 = (wxWindow *) 0 ;
51790 int arg3 = (int) 0 ;
51791 void *argp1 = 0 ;
51792 int res1 = 0 ;
51793 void *argp2 = 0 ;
51794 int res2 = 0 ;
51795 int val3 ;
51796 int ecode3 = 0 ;
51797 PyObject * obj0 = 0 ;
51798 PyObject * obj1 = 0 ;
51799 PyObject * obj2 = 0 ;
51800 char * kwnames[] = {
51801 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51802 };
51803
51804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51806 if (!SWIG_IsOK(res1)) {
51807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51808 }
51809 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51811 if (!SWIG_IsOK(res2)) {
51812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51813 }
51814 arg2 = reinterpret_cast< wxWindow * >(argp2);
51815 if (obj2) {
51816 ecode3 = SWIG_AsVal_int(obj2, &val3);
51817 if (!SWIG_IsOK(ecode3)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51819 }
51820 arg3 = static_cast< int >(val3);
51821 }
51822 {
51823 PyThreadState* __tstate = wxPyBeginAllowThreads();
51824 (arg1)->LeftOf(arg2,arg3);
51825 wxPyEndAllowThreads(__tstate);
51826 if (PyErr_Occurred()) SWIG_fail;
51827 }
51828 resultobj = SWIG_Py_Void();
51829 return resultobj;
51830 fail:
51831 return NULL;
51832 }
51833
51834
51835 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51836 PyObject *resultobj = 0;
51837 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51838 wxWindow *arg2 = (wxWindow *) 0 ;
51839 int arg3 = (int) 0 ;
51840 void *argp1 = 0 ;
51841 int res1 = 0 ;
51842 void *argp2 = 0 ;
51843 int res2 = 0 ;
51844 int val3 ;
51845 int ecode3 = 0 ;
51846 PyObject * obj0 = 0 ;
51847 PyObject * obj1 = 0 ;
51848 PyObject * obj2 = 0 ;
51849 char * kwnames[] = {
51850 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51851 };
51852
51853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51855 if (!SWIG_IsOK(res1)) {
51856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51857 }
51858 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51859 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51860 if (!SWIG_IsOK(res2)) {
51861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51862 }
51863 arg2 = reinterpret_cast< wxWindow * >(argp2);
51864 if (obj2) {
51865 ecode3 = SWIG_AsVal_int(obj2, &val3);
51866 if (!SWIG_IsOK(ecode3)) {
51867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51868 }
51869 arg3 = static_cast< int >(val3);
51870 }
51871 {
51872 PyThreadState* __tstate = wxPyBeginAllowThreads();
51873 (arg1)->RightOf(arg2,arg3);
51874 wxPyEndAllowThreads(__tstate);
51875 if (PyErr_Occurred()) SWIG_fail;
51876 }
51877 resultobj = SWIG_Py_Void();
51878 return resultobj;
51879 fail:
51880 return NULL;
51881 }
51882
51883
51884 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51885 PyObject *resultobj = 0;
51886 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51887 wxWindow *arg2 = (wxWindow *) 0 ;
51888 int arg3 = (int) 0 ;
51889 void *argp1 = 0 ;
51890 int res1 = 0 ;
51891 void *argp2 = 0 ;
51892 int res2 = 0 ;
51893 int val3 ;
51894 int ecode3 = 0 ;
51895 PyObject * obj0 = 0 ;
51896 PyObject * obj1 = 0 ;
51897 PyObject * obj2 = 0 ;
51898 char * kwnames[] = {
51899 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51900 };
51901
51902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51904 if (!SWIG_IsOK(res1)) {
51905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51906 }
51907 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51909 if (!SWIG_IsOK(res2)) {
51910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51911 }
51912 arg2 = reinterpret_cast< wxWindow * >(argp2);
51913 if (obj2) {
51914 ecode3 = SWIG_AsVal_int(obj2, &val3);
51915 if (!SWIG_IsOK(ecode3)) {
51916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51917 }
51918 arg3 = static_cast< int >(val3);
51919 }
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 (arg1)->Above(arg2,arg3);
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 resultobj = SWIG_Py_Void();
51927 return resultobj;
51928 fail:
51929 return NULL;
51930 }
51931
51932
51933 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51934 PyObject *resultobj = 0;
51935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51936 wxWindow *arg2 = (wxWindow *) 0 ;
51937 int arg3 = (int) 0 ;
51938 void *argp1 = 0 ;
51939 int res1 = 0 ;
51940 void *argp2 = 0 ;
51941 int res2 = 0 ;
51942 int val3 ;
51943 int ecode3 = 0 ;
51944 PyObject * obj0 = 0 ;
51945 PyObject * obj1 = 0 ;
51946 PyObject * obj2 = 0 ;
51947 char * kwnames[] = {
51948 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51949 };
51950
51951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51953 if (!SWIG_IsOK(res1)) {
51954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51955 }
51956 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51958 if (!SWIG_IsOK(res2)) {
51959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51960 }
51961 arg2 = reinterpret_cast< wxWindow * >(argp2);
51962 if (obj2) {
51963 ecode3 = SWIG_AsVal_int(obj2, &val3);
51964 if (!SWIG_IsOK(ecode3)) {
51965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51966 }
51967 arg3 = static_cast< int >(val3);
51968 }
51969 {
51970 PyThreadState* __tstate = wxPyBeginAllowThreads();
51971 (arg1)->Below(arg2,arg3);
51972 wxPyEndAllowThreads(__tstate);
51973 if (PyErr_Occurred()) SWIG_fail;
51974 }
51975 resultobj = SWIG_Py_Void();
51976 return resultobj;
51977 fail:
51978 return NULL;
51979 }
51980
51981
51982 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51983 PyObject *resultobj = 0;
51984 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51985 wxWindow *arg2 = (wxWindow *) 0 ;
51986 wxEdge arg3 ;
51987 int arg4 = (int) 0 ;
51988 void *argp1 = 0 ;
51989 int res1 = 0 ;
51990 void *argp2 = 0 ;
51991 int res2 = 0 ;
51992 int val3 ;
51993 int ecode3 = 0 ;
51994 int val4 ;
51995 int ecode4 = 0 ;
51996 PyObject * obj0 = 0 ;
51997 PyObject * obj1 = 0 ;
51998 PyObject * obj2 = 0 ;
51999 PyObject * obj3 = 0 ;
52000 char * kwnames[] = {
52001 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52002 };
52003
52004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52006 if (!SWIG_IsOK(res1)) {
52007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52008 }
52009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52011 if (!SWIG_IsOK(res2)) {
52012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52013 }
52014 arg2 = reinterpret_cast< wxWindow * >(argp2);
52015 ecode3 = SWIG_AsVal_int(obj2, &val3);
52016 if (!SWIG_IsOK(ecode3)) {
52017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52018 }
52019 arg3 = static_cast< wxEdge >(val3);
52020 if (obj3) {
52021 ecode4 = SWIG_AsVal_int(obj3, &val4);
52022 if (!SWIG_IsOK(ecode4)) {
52023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52024 }
52025 arg4 = static_cast< int >(val4);
52026 }
52027 {
52028 PyThreadState* __tstate = wxPyBeginAllowThreads();
52029 (arg1)->SameAs(arg2,arg3,arg4);
52030 wxPyEndAllowThreads(__tstate);
52031 if (PyErr_Occurred()) SWIG_fail;
52032 }
52033 resultobj = SWIG_Py_Void();
52034 return resultobj;
52035 fail:
52036 return NULL;
52037 }
52038
52039
52040 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52041 PyObject *resultobj = 0;
52042 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52043 wxWindow *arg2 = (wxWindow *) 0 ;
52044 wxEdge arg3 ;
52045 int arg4 ;
52046 void *argp1 = 0 ;
52047 int res1 = 0 ;
52048 void *argp2 = 0 ;
52049 int res2 = 0 ;
52050 int val3 ;
52051 int ecode3 = 0 ;
52052 int val4 ;
52053 int ecode4 = 0 ;
52054 PyObject * obj0 = 0 ;
52055 PyObject * obj1 = 0 ;
52056 PyObject * obj2 = 0 ;
52057 PyObject * obj3 = 0 ;
52058 char * kwnames[] = {
52059 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52060 };
52061
52062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52064 if (!SWIG_IsOK(res1)) {
52065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52066 }
52067 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52069 if (!SWIG_IsOK(res2)) {
52070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52071 }
52072 arg2 = reinterpret_cast< wxWindow * >(argp2);
52073 ecode3 = SWIG_AsVal_int(obj2, &val3);
52074 if (!SWIG_IsOK(ecode3)) {
52075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52076 }
52077 arg3 = static_cast< wxEdge >(val3);
52078 ecode4 = SWIG_AsVal_int(obj3, &val4);
52079 if (!SWIG_IsOK(ecode4)) {
52080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52081 }
52082 arg4 = static_cast< int >(val4);
52083 {
52084 PyThreadState* __tstate = wxPyBeginAllowThreads();
52085 (arg1)->PercentOf(arg2,arg3,arg4);
52086 wxPyEndAllowThreads(__tstate);
52087 if (PyErr_Occurred()) SWIG_fail;
52088 }
52089 resultobj = SWIG_Py_Void();
52090 return resultobj;
52091 fail:
52092 return NULL;
52093 }
52094
52095
52096 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52097 PyObject *resultobj = 0;
52098 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52099 int arg2 ;
52100 void *argp1 = 0 ;
52101 int res1 = 0 ;
52102 int val2 ;
52103 int ecode2 = 0 ;
52104 PyObject * obj0 = 0 ;
52105 PyObject * obj1 = 0 ;
52106 char * kwnames[] = {
52107 (char *) "self",(char *) "val", NULL
52108 };
52109
52110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52112 if (!SWIG_IsOK(res1)) {
52113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52114 }
52115 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52116 ecode2 = SWIG_AsVal_int(obj1, &val2);
52117 if (!SWIG_IsOK(ecode2)) {
52118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52119 }
52120 arg2 = static_cast< int >(val2);
52121 {
52122 PyThreadState* __tstate = wxPyBeginAllowThreads();
52123 (arg1)->Absolute(arg2);
52124 wxPyEndAllowThreads(__tstate);
52125 if (PyErr_Occurred()) SWIG_fail;
52126 }
52127 resultobj = SWIG_Py_Void();
52128 return resultobj;
52129 fail:
52130 return NULL;
52131 }
52132
52133
52134 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52135 PyObject *resultobj = 0;
52136 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52137 void *argp1 = 0 ;
52138 int res1 = 0 ;
52139 PyObject *swig_obj[1] ;
52140
52141 if (!args) SWIG_fail;
52142 swig_obj[0] = args;
52143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52144 if (!SWIG_IsOK(res1)) {
52145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52146 }
52147 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52148 {
52149 PyThreadState* __tstate = wxPyBeginAllowThreads();
52150 (arg1)->Unconstrained();
52151 wxPyEndAllowThreads(__tstate);
52152 if (PyErr_Occurred()) SWIG_fail;
52153 }
52154 resultobj = SWIG_Py_Void();
52155 return resultobj;
52156 fail:
52157 return NULL;
52158 }
52159
52160
52161 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52162 PyObject *resultobj = 0;
52163 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52164 void *argp1 = 0 ;
52165 int res1 = 0 ;
52166 PyObject *swig_obj[1] ;
52167
52168 if (!args) SWIG_fail;
52169 swig_obj[0] = args;
52170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52171 if (!SWIG_IsOK(res1)) {
52172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52173 }
52174 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52175 {
52176 PyThreadState* __tstate = wxPyBeginAllowThreads();
52177 (arg1)->AsIs();
52178 wxPyEndAllowThreads(__tstate);
52179 if (PyErr_Occurred()) SWIG_fail;
52180 }
52181 resultobj = SWIG_Py_Void();
52182 return resultobj;
52183 fail:
52184 return NULL;
52185 }
52186
52187
52188 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52189 PyObject *resultobj = 0;
52190 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52191 wxWindow *result = 0 ;
52192 void *argp1 = 0 ;
52193 int res1 = 0 ;
52194 PyObject *swig_obj[1] ;
52195
52196 if (!args) SWIG_fail;
52197 swig_obj[0] = args;
52198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52199 if (!SWIG_IsOK(res1)) {
52200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52201 }
52202 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52203 {
52204 PyThreadState* __tstate = wxPyBeginAllowThreads();
52205 result = (wxWindow *)(arg1)->GetOtherWindow();
52206 wxPyEndAllowThreads(__tstate);
52207 if (PyErr_Occurred()) SWIG_fail;
52208 }
52209 {
52210 resultobj = wxPyMake_wxObject(result, 0);
52211 }
52212 return resultobj;
52213 fail:
52214 return NULL;
52215 }
52216
52217
52218 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52219 PyObject *resultobj = 0;
52220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52221 wxEdge result;
52222 void *argp1 = 0 ;
52223 int res1 = 0 ;
52224 PyObject *swig_obj[1] ;
52225
52226 if (!args) SWIG_fail;
52227 swig_obj[0] = args;
52228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52229 if (!SWIG_IsOK(res1)) {
52230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52231 }
52232 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52233 {
52234 PyThreadState* __tstate = wxPyBeginAllowThreads();
52235 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52236 wxPyEndAllowThreads(__tstate);
52237 if (PyErr_Occurred()) SWIG_fail;
52238 }
52239 resultobj = SWIG_From_int(static_cast< int >(result));
52240 return resultobj;
52241 fail:
52242 return NULL;
52243 }
52244
52245
52246 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52247 PyObject *resultobj = 0;
52248 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52249 wxEdge arg2 ;
52250 void *argp1 = 0 ;
52251 int res1 = 0 ;
52252 int val2 ;
52253 int ecode2 = 0 ;
52254 PyObject * obj0 = 0 ;
52255 PyObject * obj1 = 0 ;
52256 char * kwnames[] = {
52257 (char *) "self",(char *) "which", NULL
52258 };
52259
52260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52262 if (!SWIG_IsOK(res1)) {
52263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52264 }
52265 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52266 ecode2 = SWIG_AsVal_int(obj1, &val2);
52267 if (!SWIG_IsOK(ecode2)) {
52268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52269 }
52270 arg2 = static_cast< wxEdge >(val2);
52271 {
52272 PyThreadState* __tstate = wxPyBeginAllowThreads();
52273 (arg1)->SetEdge(arg2);
52274 wxPyEndAllowThreads(__tstate);
52275 if (PyErr_Occurred()) SWIG_fail;
52276 }
52277 resultobj = SWIG_Py_Void();
52278 return resultobj;
52279 fail:
52280 return NULL;
52281 }
52282
52283
52284 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52285 PyObject *resultobj = 0;
52286 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52287 int arg2 ;
52288 void *argp1 = 0 ;
52289 int res1 = 0 ;
52290 int val2 ;
52291 int ecode2 = 0 ;
52292 PyObject * obj0 = 0 ;
52293 PyObject * obj1 = 0 ;
52294 char * kwnames[] = {
52295 (char *) "self",(char *) "v", NULL
52296 };
52297
52298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52300 if (!SWIG_IsOK(res1)) {
52301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52302 }
52303 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52304 ecode2 = SWIG_AsVal_int(obj1, &val2);
52305 if (!SWIG_IsOK(ecode2)) {
52306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52307 }
52308 arg2 = static_cast< int >(val2);
52309 {
52310 PyThreadState* __tstate = wxPyBeginAllowThreads();
52311 (arg1)->SetValue(arg2);
52312 wxPyEndAllowThreads(__tstate);
52313 if (PyErr_Occurred()) SWIG_fail;
52314 }
52315 resultobj = SWIG_Py_Void();
52316 return resultobj;
52317 fail:
52318 return NULL;
52319 }
52320
52321
52322 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52323 PyObject *resultobj = 0;
52324 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52325 int result;
52326 void *argp1 = 0 ;
52327 int res1 = 0 ;
52328 PyObject *swig_obj[1] ;
52329
52330 if (!args) SWIG_fail;
52331 swig_obj[0] = args;
52332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52333 if (!SWIG_IsOK(res1)) {
52334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52335 }
52336 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52337 {
52338 PyThreadState* __tstate = wxPyBeginAllowThreads();
52339 result = (int)(arg1)->GetMargin();
52340 wxPyEndAllowThreads(__tstate);
52341 if (PyErr_Occurred()) SWIG_fail;
52342 }
52343 resultobj = SWIG_From_int(static_cast< int >(result));
52344 return resultobj;
52345 fail:
52346 return NULL;
52347 }
52348
52349
52350 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52351 PyObject *resultobj = 0;
52352 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52353 int arg2 ;
52354 void *argp1 = 0 ;
52355 int res1 = 0 ;
52356 int val2 ;
52357 int ecode2 = 0 ;
52358 PyObject * obj0 = 0 ;
52359 PyObject * obj1 = 0 ;
52360 char * kwnames[] = {
52361 (char *) "self",(char *) "m", NULL
52362 };
52363
52364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52366 if (!SWIG_IsOK(res1)) {
52367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52368 }
52369 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52370 ecode2 = SWIG_AsVal_int(obj1, &val2);
52371 if (!SWIG_IsOK(ecode2)) {
52372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52373 }
52374 arg2 = static_cast< int >(val2);
52375 {
52376 PyThreadState* __tstate = wxPyBeginAllowThreads();
52377 (arg1)->SetMargin(arg2);
52378 wxPyEndAllowThreads(__tstate);
52379 if (PyErr_Occurred()) SWIG_fail;
52380 }
52381 resultobj = SWIG_Py_Void();
52382 return resultobj;
52383 fail:
52384 return NULL;
52385 }
52386
52387
52388 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52389 PyObject *resultobj = 0;
52390 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52391 int result;
52392 void *argp1 = 0 ;
52393 int res1 = 0 ;
52394 PyObject *swig_obj[1] ;
52395
52396 if (!args) SWIG_fail;
52397 swig_obj[0] = args;
52398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52399 if (!SWIG_IsOK(res1)) {
52400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52401 }
52402 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52403 {
52404 PyThreadState* __tstate = wxPyBeginAllowThreads();
52405 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52406 wxPyEndAllowThreads(__tstate);
52407 if (PyErr_Occurred()) SWIG_fail;
52408 }
52409 resultobj = SWIG_From_int(static_cast< int >(result));
52410 return resultobj;
52411 fail:
52412 return NULL;
52413 }
52414
52415
52416 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52417 PyObject *resultobj = 0;
52418 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52419 int result;
52420 void *argp1 = 0 ;
52421 int res1 = 0 ;
52422 PyObject *swig_obj[1] ;
52423
52424 if (!args) SWIG_fail;
52425 swig_obj[0] = args;
52426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52427 if (!SWIG_IsOK(res1)) {
52428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52429 }
52430 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52431 {
52432 PyThreadState* __tstate = wxPyBeginAllowThreads();
52433 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52434 wxPyEndAllowThreads(__tstate);
52435 if (PyErr_Occurred()) SWIG_fail;
52436 }
52437 resultobj = SWIG_From_int(static_cast< int >(result));
52438 return resultobj;
52439 fail:
52440 return NULL;
52441 }
52442
52443
52444 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52445 PyObject *resultobj = 0;
52446 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52447 int result;
52448 void *argp1 = 0 ;
52449 int res1 = 0 ;
52450 PyObject *swig_obj[1] ;
52451
52452 if (!args) SWIG_fail;
52453 swig_obj[0] = args;
52454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52455 if (!SWIG_IsOK(res1)) {
52456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52457 }
52458 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52459 {
52460 PyThreadState* __tstate = wxPyBeginAllowThreads();
52461 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52462 wxPyEndAllowThreads(__tstate);
52463 if (PyErr_Occurred()) SWIG_fail;
52464 }
52465 resultobj = SWIG_From_int(static_cast< int >(result));
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52473 PyObject *resultobj = 0;
52474 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52475 bool result;
52476 void *argp1 = 0 ;
52477 int res1 = 0 ;
52478 PyObject *swig_obj[1] ;
52479
52480 if (!args) SWIG_fail;
52481 swig_obj[0] = args;
52482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52483 if (!SWIG_IsOK(res1)) {
52484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52485 }
52486 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52487 {
52488 PyThreadState* __tstate = wxPyBeginAllowThreads();
52489 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52490 wxPyEndAllowThreads(__tstate);
52491 if (PyErr_Occurred()) SWIG_fail;
52492 }
52493 {
52494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52495 }
52496 return resultobj;
52497 fail:
52498 return NULL;
52499 }
52500
52501
52502 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52503 PyObject *resultobj = 0;
52504 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52505 bool arg2 ;
52506 void *argp1 = 0 ;
52507 int res1 = 0 ;
52508 bool val2 ;
52509 int ecode2 = 0 ;
52510 PyObject * obj0 = 0 ;
52511 PyObject * obj1 = 0 ;
52512 char * kwnames[] = {
52513 (char *) "self",(char *) "d", NULL
52514 };
52515
52516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52518 if (!SWIG_IsOK(res1)) {
52519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52520 }
52521 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52522 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52523 if (!SWIG_IsOK(ecode2)) {
52524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52525 }
52526 arg2 = static_cast< bool >(val2);
52527 {
52528 PyThreadState* __tstate = wxPyBeginAllowThreads();
52529 (arg1)->SetDone(arg2);
52530 wxPyEndAllowThreads(__tstate);
52531 if (PyErr_Occurred()) SWIG_fail;
52532 }
52533 resultobj = SWIG_Py_Void();
52534 return resultobj;
52535 fail:
52536 return NULL;
52537 }
52538
52539
52540 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52541 PyObject *resultobj = 0;
52542 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52543 wxRelationship result;
52544 void *argp1 = 0 ;
52545 int res1 = 0 ;
52546 PyObject *swig_obj[1] ;
52547
52548 if (!args) SWIG_fail;
52549 swig_obj[0] = args;
52550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52551 if (!SWIG_IsOK(res1)) {
52552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52553 }
52554 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52555 {
52556 PyThreadState* __tstate = wxPyBeginAllowThreads();
52557 result = (wxRelationship)(arg1)->GetRelationship();
52558 wxPyEndAllowThreads(__tstate);
52559 if (PyErr_Occurred()) SWIG_fail;
52560 }
52561 resultobj = SWIG_From_int(static_cast< int >(result));
52562 return resultobj;
52563 fail:
52564 return NULL;
52565 }
52566
52567
52568 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52569 PyObject *resultobj = 0;
52570 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52571 wxRelationship arg2 ;
52572 void *argp1 = 0 ;
52573 int res1 = 0 ;
52574 int val2 ;
52575 int ecode2 = 0 ;
52576 PyObject * obj0 = 0 ;
52577 PyObject * obj1 = 0 ;
52578 char * kwnames[] = {
52579 (char *) "self",(char *) "r", NULL
52580 };
52581
52582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52584 if (!SWIG_IsOK(res1)) {
52585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52586 }
52587 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52588 ecode2 = SWIG_AsVal_int(obj1, &val2);
52589 if (!SWIG_IsOK(ecode2)) {
52590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52591 }
52592 arg2 = static_cast< wxRelationship >(val2);
52593 {
52594 PyThreadState* __tstate = wxPyBeginAllowThreads();
52595 (arg1)->SetRelationship(arg2);
52596 wxPyEndAllowThreads(__tstate);
52597 if (PyErr_Occurred()) SWIG_fail;
52598 }
52599 resultobj = SWIG_Py_Void();
52600 return resultobj;
52601 fail:
52602 return NULL;
52603 }
52604
52605
52606 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52607 PyObject *resultobj = 0;
52608 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52609 wxWindow *arg2 = (wxWindow *) 0 ;
52610 bool result;
52611 void *argp1 = 0 ;
52612 int res1 = 0 ;
52613 void *argp2 = 0 ;
52614 int res2 = 0 ;
52615 PyObject * obj0 = 0 ;
52616 PyObject * obj1 = 0 ;
52617 char * kwnames[] = {
52618 (char *) "self",(char *) "otherW", NULL
52619 };
52620
52621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52623 if (!SWIG_IsOK(res1)) {
52624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52625 }
52626 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52628 if (!SWIG_IsOK(res2)) {
52629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52630 }
52631 arg2 = reinterpret_cast< wxWindow * >(argp2);
52632 {
52633 PyThreadState* __tstate = wxPyBeginAllowThreads();
52634 result = (bool)(arg1)->ResetIfWin(arg2);
52635 wxPyEndAllowThreads(__tstate);
52636 if (PyErr_Occurred()) SWIG_fail;
52637 }
52638 {
52639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52640 }
52641 return resultobj;
52642 fail:
52643 return NULL;
52644 }
52645
52646
52647 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52648 PyObject *resultobj = 0;
52649 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52650 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52651 wxWindow *arg3 = (wxWindow *) 0 ;
52652 bool result;
52653 void *argp1 = 0 ;
52654 int res1 = 0 ;
52655 void *argp2 = 0 ;
52656 int res2 = 0 ;
52657 void *argp3 = 0 ;
52658 int res3 = 0 ;
52659 PyObject * obj0 = 0 ;
52660 PyObject * obj1 = 0 ;
52661 PyObject * obj2 = 0 ;
52662 char * kwnames[] = {
52663 (char *) "self",(char *) "constraints",(char *) "win", NULL
52664 };
52665
52666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52668 if (!SWIG_IsOK(res1)) {
52669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52670 }
52671 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52673 if (!SWIG_IsOK(res2)) {
52674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52675 }
52676 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52677 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52678 if (!SWIG_IsOK(res3)) {
52679 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52680 }
52681 arg3 = reinterpret_cast< wxWindow * >(argp3);
52682 {
52683 PyThreadState* __tstate = wxPyBeginAllowThreads();
52684 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52685 wxPyEndAllowThreads(__tstate);
52686 if (PyErr_Occurred()) SWIG_fail;
52687 }
52688 {
52689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52690 }
52691 return resultobj;
52692 fail:
52693 return NULL;
52694 }
52695
52696
52697 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52698 PyObject *resultobj = 0;
52699 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52700 wxEdge arg2 ;
52701 wxWindow *arg3 = (wxWindow *) 0 ;
52702 wxWindow *arg4 = (wxWindow *) 0 ;
52703 int result;
52704 void *argp1 = 0 ;
52705 int res1 = 0 ;
52706 int val2 ;
52707 int ecode2 = 0 ;
52708 void *argp3 = 0 ;
52709 int res3 = 0 ;
52710 void *argp4 = 0 ;
52711 int res4 = 0 ;
52712 PyObject * obj0 = 0 ;
52713 PyObject * obj1 = 0 ;
52714 PyObject * obj2 = 0 ;
52715 PyObject * obj3 = 0 ;
52716 char * kwnames[] = {
52717 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52718 };
52719
52720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52722 if (!SWIG_IsOK(res1)) {
52723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52724 }
52725 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52726 ecode2 = SWIG_AsVal_int(obj1, &val2);
52727 if (!SWIG_IsOK(ecode2)) {
52728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52729 }
52730 arg2 = static_cast< wxEdge >(val2);
52731 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52732 if (!SWIG_IsOK(res3)) {
52733 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52734 }
52735 arg3 = reinterpret_cast< wxWindow * >(argp3);
52736 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52737 if (!SWIG_IsOK(res4)) {
52738 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52739 }
52740 arg4 = reinterpret_cast< wxWindow * >(argp4);
52741 {
52742 PyThreadState* __tstate = wxPyBeginAllowThreads();
52743 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52744 wxPyEndAllowThreads(__tstate);
52745 if (PyErr_Occurred()) SWIG_fail;
52746 }
52747 resultobj = SWIG_From_int(static_cast< int >(result));
52748 return resultobj;
52749 fail:
52750 return NULL;
52751 }
52752
52753
52754 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52755 PyObject *obj;
52756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52757 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52758 return SWIG_Py_Void();
52759 }
52760
52761 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52762 PyObject *resultobj = 0;
52763 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52764 wxIndividualLayoutConstraint *result = 0 ;
52765 void *argp1 = 0 ;
52766 int res1 = 0 ;
52767 PyObject *swig_obj[1] ;
52768
52769 if (!args) SWIG_fail;
52770 swig_obj[0] = args;
52771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52772 if (!SWIG_IsOK(res1)) {
52773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52774 }
52775 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52776 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52778 return resultobj;
52779 fail:
52780 return NULL;
52781 }
52782
52783
52784 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52785 PyObject *resultobj = 0;
52786 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52787 wxIndividualLayoutConstraint *result = 0 ;
52788 void *argp1 = 0 ;
52789 int res1 = 0 ;
52790 PyObject *swig_obj[1] ;
52791
52792 if (!args) SWIG_fail;
52793 swig_obj[0] = args;
52794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52795 if (!SWIG_IsOK(res1)) {
52796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52797 }
52798 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52799 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52801 return resultobj;
52802 fail:
52803 return NULL;
52804 }
52805
52806
52807 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52808 PyObject *resultobj = 0;
52809 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52810 wxIndividualLayoutConstraint *result = 0 ;
52811 void *argp1 = 0 ;
52812 int res1 = 0 ;
52813 PyObject *swig_obj[1] ;
52814
52815 if (!args) SWIG_fail;
52816 swig_obj[0] = args;
52817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52818 if (!SWIG_IsOK(res1)) {
52819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52820 }
52821 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52822 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52824 return resultobj;
52825 fail:
52826 return NULL;
52827 }
52828
52829
52830 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52831 PyObject *resultobj = 0;
52832 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52833 wxIndividualLayoutConstraint *result = 0 ;
52834 void *argp1 = 0 ;
52835 int res1 = 0 ;
52836 PyObject *swig_obj[1] ;
52837
52838 if (!args) SWIG_fail;
52839 swig_obj[0] = args;
52840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52841 if (!SWIG_IsOK(res1)) {
52842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52843 }
52844 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52845 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52847 return resultobj;
52848 fail:
52849 return NULL;
52850 }
52851
52852
52853 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52854 PyObject *resultobj = 0;
52855 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52856 wxIndividualLayoutConstraint *result = 0 ;
52857 void *argp1 = 0 ;
52858 int res1 = 0 ;
52859 PyObject *swig_obj[1] ;
52860
52861 if (!args) SWIG_fail;
52862 swig_obj[0] = args;
52863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52864 if (!SWIG_IsOK(res1)) {
52865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52866 }
52867 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52868 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52870 return resultobj;
52871 fail:
52872 return NULL;
52873 }
52874
52875
52876 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52877 PyObject *resultobj = 0;
52878 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52879 wxIndividualLayoutConstraint *result = 0 ;
52880 void *argp1 = 0 ;
52881 int res1 = 0 ;
52882 PyObject *swig_obj[1] ;
52883
52884 if (!args) SWIG_fail;
52885 swig_obj[0] = args;
52886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52887 if (!SWIG_IsOK(res1)) {
52888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52889 }
52890 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52891 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52893 return resultobj;
52894 fail:
52895 return NULL;
52896 }
52897
52898
52899 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52900 PyObject *resultobj = 0;
52901 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52902 wxIndividualLayoutConstraint *result = 0 ;
52903 void *argp1 = 0 ;
52904 int res1 = 0 ;
52905 PyObject *swig_obj[1] ;
52906
52907 if (!args) SWIG_fail;
52908 swig_obj[0] = args;
52909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52910 if (!SWIG_IsOK(res1)) {
52911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52912 }
52913 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52914 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52916 return resultobj;
52917 fail:
52918 return NULL;
52919 }
52920
52921
52922 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52923 PyObject *resultobj = 0;
52924 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52925 wxIndividualLayoutConstraint *result = 0 ;
52926 void *argp1 = 0 ;
52927 int res1 = 0 ;
52928 PyObject *swig_obj[1] ;
52929
52930 if (!args) SWIG_fail;
52931 swig_obj[0] = args;
52932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52933 if (!SWIG_IsOK(res1)) {
52934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52935 }
52936 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52937 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52939 return resultobj;
52940 fail:
52941 return NULL;
52942 }
52943
52944
52945 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52946 PyObject *resultobj = 0;
52947 wxLayoutConstraints *result = 0 ;
52948
52949 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52950 {
52951 PyThreadState* __tstate = wxPyBeginAllowThreads();
52952 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52953 wxPyEndAllowThreads(__tstate);
52954 if (PyErr_Occurred()) SWIG_fail;
52955 }
52956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52957 return resultobj;
52958 fail:
52959 return NULL;
52960 }
52961
52962
52963 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52964 PyObject *resultobj = 0;
52965 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52966 void *argp1 = 0 ;
52967 int res1 = 0 ;
52968 PyObject *swig_obj[1] ;
52969
52970 if (!args) SWIG_fail;
52971 swig_obj[0] = args;
52972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52973 if (!SWIG_IsOK(res1)) {
52974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52975 }
52976 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52977 {
52978 PyThreadState* __tstate = wxPyBeginAllowThreads();
52979 delete arg1;
52980
52981 wxPyEndAllowThreads(__tstate);
52982 if (PyErr_Occurred()) SWIG_fail;
52983 }
52984 resultobj = SWIG_Py_Void();
52985 return resultobj;
52986 fail:
52987 return NULL;
52988 }
52989
52990
52991 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52992 PyObject *resultobj = 0;
52993 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52994 wxWindow *arg2 = (wxWindow *) 0 ;
52995 int *arg3 = (int *) 0 ;
52996 bool result;
52997 void *argp1 = 0 ;
52998 int res1 = 0 ;
52999 void *argp2 = 0 ;
53000 int res2 = 0 ;
53001 int temp3 ;
53002 int res3 = SWIG_TMPOBJ ;
53003 PyObject * obj0 = 0 ;
53004 PyObject * obj1 = 0 ;
53005 char * kwnames[] = {
53006 (char *) "self",(char *) "win", NULL
53007 };
53008
53009 arg3 = &temp3;
53010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53012 if (!SWIG_IsOK(res1)) {
53013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53014 }
53015 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53017 if (!SWIG_IsOK(res2)) {
53018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53019 }
53020 arg2 = reinterpret_cast< wxWindow * >(argp2);
53021 {
53022 PyThreadState* __tstate = wxPyBeginAllowThreads();
53023 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53024 wxPyEndAllowThreads(__tstate);
53025 if (PyErr_Occurred()) SWIG_fail;
53026 }
53027 {
53028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53029 }
53030 if (SWIG_IsTmpObj(res3)) {
53031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53032 } else {
53033 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53035 }
53036 return resultobj;
53037 fail:
53038 return NULL;
53039 }
53040
53041
53042 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53043 PyObject *resultobj = 0;
53044 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53045 bool result;
53046 void *argp1 = 0 ;
53047 int res1 = 0 ;
53048 PyObject *swig_obj[1] ;
53049
53050 if (!args) SWIG_fail;
53051 swig_obj[0] = args;
53052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53053 if (!SWIG_IsOK(res1)) {
53054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53055 }
53056 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53057 {
53058 PyThreadState* __tstate = wxPyBeginAllowThreads();
53059 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53060 wxPyEndAllowThreads(__tstate);
53061 if (PyErr_Occurred()) SWIG_fail;
53062 }
53063 {
53064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53065 }
53066 return resultobj;
53067 fail:
53068 return NULL;
53069 }
53070
53071
53072 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53073 PyObject *obj;
53074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53075 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53076 return SWIG_Py_Void();
53077 }
53078
53079 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53080 return SWIG_Python_InitShadowInstance(args);
53081 }
53082
53083 static PyMethodDef SwigMethods[] = {
53084 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53085 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53086 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53087 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53088 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53089 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53090 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53091 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53092 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53094 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53105 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53106 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53107 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53109 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53110 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53111 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53112 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53113 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53114 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53115 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53117 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53123 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53124 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53125 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53126 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53127 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53128 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53129 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53131 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53139 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53140 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53141 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53146 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53147 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53149 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53151 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53153 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53155 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53157 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53159 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53160 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53162 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53164 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53165 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53166 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53167 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53187 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53188 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53189 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53190 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53191 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53192 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53193 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53194 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53196 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53197 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53198 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53203 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53204 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53205 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53206 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53213 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53220 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53221 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53222 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53223 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53225 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53226 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53227 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53229 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53230 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53231 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53232 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53237 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53238 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53239 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53240 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53241 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53242 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53245 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53246 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53247 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53249 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53250 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53252 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53253 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53254 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53255 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53256 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53257 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53258 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53259 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53260 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53261 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53262 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53267 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53273 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53274 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53275 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53276 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53278 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53281 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53283 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53286 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53287 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53288 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53291 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53292 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53293 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53297 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53298 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53299 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53303 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53308 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53309 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53310 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53311 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53312 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53313 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53314 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53321 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53322 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53324 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53325 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53326 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53332 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53333 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53335 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53336 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53337 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53338 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53339 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53340 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53341 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53342 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53344 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53345 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53346 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53347 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53348 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53349 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53350 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53351 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53353 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53362 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53374 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53375 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53390 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53391 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53392 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53393 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53396 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53398 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53400 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53402 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53404 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53407 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53408 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53409 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53410 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53412 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53429 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53430 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53436 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53437 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53439 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53440 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53441 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53442 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53443 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53444 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53445 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53446 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53447 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53448 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53449 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53450 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53451 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53452 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53453 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53454 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53455 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53456 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53457 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53458 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53459 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53460 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53461 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53462 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53463 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53464 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53465 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53466 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53467 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53468 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53469 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53470 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53471 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53473 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53474 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53475 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53476 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53479 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53483 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53487 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53488 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53489 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53490 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53492 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53493 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53495 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53497 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53499 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53501 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53502 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53503 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53505 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53506 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53508 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53509 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53510 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53512 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53513 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53514 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53516 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53518 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53519 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53520 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53522 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53524 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53525 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53527 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53528 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53529 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53531 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53532 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53533 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53534 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53535 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53537 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53538 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53541 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53542 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53544 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53545 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53548 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53549 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53551 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53557 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53558 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53559 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53560 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53561 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53562 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53563 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53564 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53565 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53566 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53567 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53568 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53569 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53570 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53571 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53572 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53573 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53574 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53575 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53576 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53577 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53578 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53579 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53580 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53582 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53583 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53584 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53585 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53586 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53587 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53588 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53589 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53590 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53591 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53592 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53593 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53594 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53595 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53596 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53597 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53598 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53599 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53600 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53601 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53602 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53603 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53604 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53605 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53606 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53607 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53608 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53609 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53610 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53611 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53612 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53613 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53615 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53616 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53618 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53619 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53620 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53621 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53623 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53624 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53625 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53626 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53627 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53628 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53629 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53630 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53631 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53633 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53634 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53635 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53636 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53637 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53638 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53639 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53640 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53641 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53642 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53643 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53644 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53645 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53646 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53647 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53648 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53649 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53650 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53651 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53652 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53653 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53654 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53655 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53656 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53657 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53658 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53659 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53660 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53662 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53663 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53666 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53667 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53668 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53669 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53670 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53671 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53673 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53674 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53677 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53678 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53680 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53681 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53683 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53684 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53686 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53687 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53688 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53690 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53692 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53693 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53695 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53696 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53697 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53699 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53700 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53701 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53703 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53704 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53706 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53707 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53708 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53709 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53710 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53713 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53715 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53717 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53718 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53719 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53722 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53723 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53724 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53726 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53727 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53728 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53730 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53731 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53732 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53733 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53734 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53735 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53737 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53738 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53739 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53740 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53741 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53742 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53743 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53744 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53750 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53752 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53754 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53755 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53756 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53757 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53758 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53759 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53761 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53762 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53763 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53765 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53766 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53767 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53768 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53769 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53772 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53773 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53774 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53777 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53778 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53779 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53780 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53781 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53783 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53785 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53788 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53790 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53791 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53793 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53794 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53795 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53797 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53798 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53799 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53801 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53803 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53804 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53805 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53807 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53809 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53811 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53812 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53814 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53815 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53817 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53819 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53820 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53821 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53823 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53825 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53826 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53827 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53829 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53831 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53832 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53833 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53834 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53836 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53838 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53840 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53842 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53843 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53845 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53846 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53847 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53848 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53849 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53850 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53851 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53852 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53854 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53856 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53858 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53860 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53862 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53864 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53865 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53866 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53867 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53868 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53869 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53875 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53876 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53877 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53878 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53879 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53880 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53881 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53882 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53884 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53886 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53887 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53889 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53890 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53891 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53892 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53894 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53895 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53896 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53897 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53899 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53900 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53902 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53903 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53904 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53906 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53908 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53909 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53910 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53911 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53912 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53914 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53915 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53916 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53917 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53919 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53920 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53921 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53922 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53923 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53924 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53925 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53926 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53927 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53928 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53930 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53933 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53934 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53935 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53937 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53939 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53941 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53943 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53944 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53954 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53955 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53959 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53960 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53961 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53962 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53963 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53964 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53965 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53966 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53967 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53968 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53969 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53970 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53971 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53972 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53973 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53975 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53976 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53979 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53980 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53985 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53986 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53989 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53990 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53991 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53992 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53995 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53996 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53997 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53999 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54001 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54002 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54003 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54005 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54007 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54009 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54012 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54013 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54014 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54015 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54016 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54017 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54021 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54022 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54023 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54024 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54031 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54037 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54038 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54039 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54040 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54041 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54043 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54053 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54054 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54055 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54056 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54059 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54060 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54061 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54062 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54064 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54065 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54069 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54075 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54076 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54077 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54078 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54080 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54081 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54083 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54086 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54088 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54089 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54090 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54099 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54103 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54104 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54106 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54117 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54118 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54119 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54120 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54124 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54127 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54129 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54132 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54134 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54135 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54138 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54140 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54141 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54142 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54143 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54145 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54146 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54151 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54152 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54153 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54155 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54156 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54157 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54159 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54161 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54162 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54163 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54165 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54166 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54169 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54177 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54184 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54192 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54195 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54196 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54209 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54211 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54213 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54214 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54216 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54218 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54219 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54221 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54222 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54223 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54227 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54246 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54247 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54249 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54250 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54252 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54253 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54254 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54256 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54257 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54260 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54261 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54263 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54264 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54266 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54269 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54270 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54272 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54274 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54276 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54277 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54279 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54280 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54283 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54285 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54287 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54289 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54291 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54292 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54294 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54295 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54296 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54298 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54299 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54300 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54302 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54304 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54305 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54307 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54309 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54310 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54314 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54318 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54319 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54321 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54325 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54327 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54329 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54330 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54331 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54332 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54336 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54337 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54338 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54339 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54341 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54342 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54347 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54348 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54349 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54350 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54351 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54353 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54355 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54357 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54358 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54360 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54362 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54365 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54366 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54367 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54369 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54370 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54371 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54385 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54386 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54387 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54388 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54389 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54390 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54396 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54397 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54401 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54402 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54404 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54405 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54407 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54409 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54410 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54412 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54413 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54414 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54420 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54421 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54422 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54423 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54424 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54425 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54432 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54434 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54435 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54436 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54437 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54438 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54439 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54441 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54445 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54446 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54447 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54448 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54449 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54450 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54451 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54453 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54454 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54455 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54461 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54462 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54463 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54465 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54466 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54467 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54473 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54474 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54475 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54476 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54477 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54481 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54482 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54487 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54488 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54490 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54491 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54496 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54498 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54499 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54500 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54501 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54502 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54507 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54508 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54509 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54517 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54518 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54519 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54520 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54523 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54525 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54526 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54527 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54528 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54529 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54530 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54531 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54534 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54535 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54536 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54537 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54538 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54539 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54540 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54541 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54542 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54543 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54544 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54545 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54547 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54548 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54549 { NULL, NULL, 0, NULL }
54550 };
54551
54552
54553 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54554
54555 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54556 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54557 }
54558 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54559 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54560 }
54561 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54562 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54563 }
54564 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54565 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54566 }
54567 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54568 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54569 }
54570 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54571 return (void *)((wxSizer *) ((wxGridSizer *) x));
54572 }
54573 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54574 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54575 }
54576 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54577 return (void *)((wxSizer *) ((wxPySizer *) x));
54578 }
54579 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54580 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54581 }
54582 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54583 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54584 }
54585 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54586 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54587 }
54588 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54589 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54590 }
54591 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54592 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54593 }
54594 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54595 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54596 }
54597 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54598 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54599 }
54600 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54601 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54602 }
54603 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54604 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54605 }
54606 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54607 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54608 }
54609 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54610 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54611 }
54612 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54613 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54614 }
54615 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54616 return (void *)((wxEvent *) ((wxPyEvent *) x));
54617 }
54618 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54619 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54620 }
54621 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54622 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54623 }
54624 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54625 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54626 }
54627 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54628 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54629 }
54630 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54631 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54632 }
54633 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54634 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54635 }
54636 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54637 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54638 }
54639 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54640 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54641 }
54642 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54643 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54644 }
54645 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54646 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54647 }
54648 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54649 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54650 }
54651 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54652 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54653 }
54654 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54655 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54656 }
54657 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54658 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54659 }
54660 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54661 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54662 }
54663 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54664 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54665 }
54666 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54667 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54668 }
54669 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54670 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54671 }
54672 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54673 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54674 }
54675 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54676 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54677 }
54678 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54679 return (void *)((wxEvent *) ((wxShowEvent *) x));
54680 }
54681 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54682 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54683 }
54684 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54685 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54686 }
54687 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54688 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54689 }
54690 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54691 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54692 }
54693 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54694 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54695 }
54696 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54697 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54698 }
54699 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54700 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54701 }
54702 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54703 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54704 }
54705 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54706 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54707 }
54708 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54709 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54710 }
54711 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54712 return (void *)((wxControl *) ((wxControlWithItems *) x));
54713 }
54714 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54715 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54716 }
54717 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54718 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54719 }
54720 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54721 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54722 }
54723 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54724 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54725 }
54726 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54727 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54728 }
54729 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54730 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54731 }
54732 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54733 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54734 }
54735 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54736 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54737 }
54738 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54739 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54740 }
54741 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54742 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54743 }
54744 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54745 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54746 }
54747 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54748 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54749 }
54750 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54751 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54752 }
54753 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54754 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54755 }
54756 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54757 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54758 }
54759 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54760 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54761 }
54762 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54763 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54764 }
54765 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54766 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54767 }
54768 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54769 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54770 }
54771 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54772 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54773 }
54774 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54775 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54776 }
54777 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54778 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54779 }
54780 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54781 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54782 }
54783 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54784 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54785 }
54786 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54787 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54788 }
54789 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54790 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54791 }
54792 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54793 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54794 }
54795 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54796 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54797 }
54798 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54799 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54800 }
54801 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54802 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54803 }
54804 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54805 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54806 }
54807 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54808 return (void *)((wxObject *) ((wxSizerItem *) x));
54809 }
54810 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54811 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54812 }
54813 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54814 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54815 }
54816 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54817 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54818 }
54819 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54820 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54821 }
54822 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54823 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54824 }
54825 static void *_p_wxSizerTo_p_wxObject(void *x) {
54826 return (void *)((wxObject *) ((wxSizer *) x));
54827 }
54828 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54829 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54830 }
54831 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54832 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54833 }
54834 static void *_p_wxEventTo_p_wxObject(void *x) {
54835 return (void *)((wxObject *) ((wxEvent *) x));
54836 }
54837 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54838 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54839 }
54840 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54841 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54842 }
54843 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54844 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54845 }
54846 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54847 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54848 }
54849 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54850 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54851 }
54852 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54853 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54854 }
54855 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54856 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54857 }
54858 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54859 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54860 }
54861 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54862 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54863 }
54864 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54865 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54866 }
54867 static void *_p_wxControlTo_p_wxObject(void *x) {
54868 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54869 }
54870 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54871 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54872 }
54873 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54874 return (void *)((wxObject *) ((wxFSFile *) x));
54875 }
54876 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54877 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54878 }
54879 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54880 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54881 }
54882 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54883 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54884 }
54885 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54886 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54887 }
54888 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54889 return (void *)((wxObject *) ((wxMenuItem *) x));
54890 }
54891 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54892 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54893 }
54894 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54895 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54896 }
54897 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54898 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54899 }
54900 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54901 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54902 }
54903 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54904 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54905 }
54906 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54907 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54908 }
54909 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54910 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54911 }
54912 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54913 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54914 }
54915 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54916 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54917 }
54918 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54919 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54920 }
54921 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54922 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54923 }
54924 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54925 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54926 }
54927 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54928 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54929 }
54930 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54931 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54932 }
54933 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54934 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54935 }
54936 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54937 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54938 }
54939 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54940 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54941 }
54942 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54943 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54944 }
54945 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54946 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54947 }
54948 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54949 return (void *)((wxObject *) ((wxImageHandler *) x));
54950 }
54951 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54952 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54953 }
54954 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54955 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54956 }
54957 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54958 return (void *)((wxObject *) ((wxEvtHandler *) x));
54959 }
54960 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54961 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54962 }
54963 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54964 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54965 }
54966 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54967 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54968 }
54969 static void *_p_wxImageTo_p_wxObject(void *x) {
54970 return (void *)((wxObject *) ((wxImage *) x));
54971 }
54972 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54973 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54974 }
54975 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54976 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54977 }
54978 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54979 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54980 }
54981 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54982 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54983 }
54984 static void *_p_wxWindowTo_p_wxObject(void *x) {
54985 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54986 }
54987 static void *_p_wxMenuTo_p_wxObject(void *x) {
54988 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54989 }
54990 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54991 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54992 }
54993 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54994 return (void *)((wxObject *) ((wxFileSystem *) x));
54995 }
54996 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54997 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54998 }
54999 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55000 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55001 }
55002 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55003 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55004 }
55005 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55006 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55007 }
55008 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55009 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55010 }
55011 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55012 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55013 }
55014 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55015 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55016 }
55017 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55018 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55019 }
55020 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55021 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55022 }
55023 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55024 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55025 }
55026 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55027 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55028 }
55029 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55030 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55031 }
55032 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55033 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55034 }
55035 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55036 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55037 }
55038 static void *_p_wxControlTo_p_wxWindow(void *x) {
55039 return (void *)((wxWindow *) ((wxControl *) x));
55040 }
55041 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55042 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55043 }
55044 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55045 return (void *)((wxWindow *) ((wxMenuBar *) x));
55046 }
55047 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55048 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55049 }
55050 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55051 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55052 }
55053 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55054 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55055 }
55056 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55057 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55058 }
55059 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55060 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55061 }
55062 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55063 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55064 }
55065 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55066 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55067 }
55068 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55069 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55070 }
55071 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55072 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55073 }
55074 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55075 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55076 }
55077 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55078 return (void *)((wxValidator *) ((wxPyValidator *) x));
55079 }
55080 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55082 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};
55083 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55168 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55169 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55170 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55171 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55172 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55173 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55174 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55175 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55176 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55177 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55178 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55179 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55180 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55181 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55182 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55183 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55184 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55185 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55186 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55187 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55188 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55189 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55190 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55191 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55192 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55193 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55194 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55195 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55196 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55197 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55198 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55199 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55200 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55201 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55202 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55203 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55204 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55205 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55206 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55207 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55208 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55209 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55210 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55211 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55212
55213 static swig_type_info *swig_type_initial[] = {
55214 &_swigt__p_buffer,
55215 &_swigt__p_char,
55216 &_swigt__p_form_ops_t,
55217 &_swigt__p_int,
55218 &_swigt__p_long,
55219 &_swigt__p_unsigned_char,
55220 &_swigt__p_unsigned_int,
55221 &_swigt__p_unsigned_long,
55222 &_swigt__p_wxANIHandler,
55223 &_swigt__p_wxAcceleratorEntry,
55224 &_swigt__p_wxAcceleratorTable,
55225 &_swigt__p_wxActivateEvent,
55226 &_swigt__p_wxAppTraits,
55227 &_swigt__p_wxArrayString,
55228 &_swigt__p_wxBMPHandler,
55229 &_swigt__p_wxBitmap,
55230 &_swigt__p_wxBoxSizer,
55231 &_swigt__p_wxButton,
55232 &_swigt__p_wxCURHandler,
55233 &_swigt__p_wxCaret,
55234 &_swigt__p_wxChildFocusEvent,
55235 &_swigt__p_wxClipboardTextEvent,
55236 &_swigt__p_wxCloseEvent,
55237 &_swigt__p_wxColour,
55238 &_swigt__p_wxCommandEvent,
55239 &_swigt__p_wxContextMenuEvent,
55240 &_swigt__p_wxControl,
55241 &_swigt__p_wxControlWithItems,
55242 &_swigt__p_wxCursor,
55243 &_swigt__p_wxDC,
55244 &_swigt__p_wxDateEvent,
55245 &_swigt__p_wxDateTime,
55246 &_swigt__p_wxDisplayChangedEvent,
55247 &_swigt__p_wxDropFilesEvent,
55248 &_swigt__p_wxDuplexMode,
55249 &_swigt__p_wxEraseEvent,
55250 &_swigt__p_wxEvent,
55251 &_swigt__p_wxEventLoop,
55252 &_swigt__p_wxEventLoopActivator,
55253 &_swigt__p_wxEvtHandler,
55254 &_swigt__p_wxFSFile,
55255 &_swigt__p_wxFileSystem,
55256 &_swigt__p_wxFileSystemHandler,
55257 &_swigt__p_wxFlexGridSizer,
55258 &_swigt__p_wxFocusEvent,
55259 &_swigt__p_wxFont,
55260 &_swigt__p_wxFrame,
55261 &_swigt__p_wxGBPosition,
55262 &_swigt__p_wxGBSizerItem,
55263 &_swigt__p_wxGBSpan,
55264 &_swigt__p_wxGIFHandler,
55265 &_swigt__p_wxGridBagSizer,
55266 &_swigt__p_wxGridSizer,
55267 &_swigt__p_wxHelpEvent__Origin,
55268 &_swigt__p_wxICOHandler,
55269 &_swigt__p_wxIconizeEvent,
55270 &_swigt__p_wxIdleEvent,
55271 &_swigt__p_wxImage,
55272 &_swigt__p_wxImageHandler,
55273 &_swigt__p_wxImageHistogram,
55274 &_swigt__p_wxImage_HSVValue,
55275 &_swigt__p_wxImage_RGBValue,
55276 &_swigt__p_wxIndividualLayoutConstraint,
55277 &_swigt__p_wxInitDialogEvent,
55278 &_swigt__p_wxInputStream,
55279 &_swigt__p_wxInternetFSHandler,
55280 &_swigt__p_wxItemContainer,
55281 &_swigt__p_wxJPEGHandler,
55282 &_swigt__p_wxKeyEvent,
55283 &_swigt__p_wxLayoutConstraints,
55284 &_swigt__p_wxMaximizeEvent,
55285 &_swigt__p_wxMemoryFSHandler,
55286 &_swigt__p_wxMenu,
55287 &_swigt__p_wxMenuBar,
55288 &_swigt__p_wxMenuBarBase,
55289 &_swigt__p_wxMenuEvent,
55290 &_swigt__p_wxMenuItem,
55291 &_swigt__p_wxMouseCaptureChangedEvent,
55292 &_swigt__p_wxMouseCaptureLostEvent,
55293 &_swigt__p_wxMouseEvent,
55294 &_swigt__p_wxMoveEvent,
55295 &_swigt__p_wxNavigationKeyEvent,
55296 &_swigt__p_wxNcPaintEvent,
55297 &_swigt__p_wxNotifyEvent,
55298 &_swigt__p_wxObject,
55299 &_swigt__p_wxOutputStream,
55300 &_swigt__p_wxPCXHandler,
55301 &_swigt__p_wxPNGHandler,
55302 &_swigt__p_wxPNMHandler,
55303 &_swigt__p_wxPaintEvent,
55304 &_swigt__p_wxPaletteChangedEvent,
55305 &_swigt__p_wxPaperSize,
55306 &_swigt__p_wxPoint,
55307 &_swigt__p_wxPoint2D,
55308 &_swigt__p_wxPropagateOnce,
55309 &_swigt__p_wxPropagationDisabler,
55310 &_swigt__p_wxPyApp,
55311 &_swigt__p_wxPyCommandEvent,
55312 &_swigt__p_wxPyDropTarget,
55313 &_swigt__p_wxPyEvent,
55314 &_swigt__p_wxPyFileSystemHandler,
55315 &_swigt__p_wxPyImageHandler,
55316 &_swigt__p_wxPyInputStream,
55317 &_swigt__p_wxPySizer,
55318 &_swigt__p_wxPyValidator,
55319 &_swigt__p_wxQuantize,
55320 &_swigt__p_wxQueryNewPaletteEvent,
55321 &_swigt__p_wxRealPoint,
55322 &_swigt__p_wxRect,
55323 &_swigt__p_wxRegion,
55324 &_swigt__p_wxScrollEvent,
55325 &_swigt__p_wxScrollWinEvent,
55326 &_swigt__p_wxSetCursorEvent,
55327 &_swigt__p_wxShowEvent,
55328 &_swigt__p_wxSize,
55329 &_swigt__p_wxSizeEvent,
55330 &_swigt__p_wxSizer,
55331 &_swigt__p_wxSizerItem,
55332 &_swigt__p_wxStaticBox,
55333 &_swigt__p_wxStaticBoxSizer,
55334 &_swigt__p_wxStdDialogButtonSizer,
55335 &_swigt__p_wxSysColourChangedEvent,
55336 &_swigt__p_wxTIFFHandler,
55337 &_swigt__p_wxToolTip,
55338 &_swigt__p_wxUpdateUIEvent,
55339 &_swigt__p_wxValidator,
55340 &_swigt__p_wxVisualAttributes,
55341 &_swigt__p_wxWindow,
55342 &_swigt__p_wxWindowCreateEvent,
55343 &_swigt__p_wxWindowDestroyEvent,
55344 &_swigt__p_wxXPMHandler,
55345 &_swigt__p_wxZipFSHandler,
55346 };
55347
55348 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55349 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55353 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55354 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55355 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55356 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55357 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55358 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55359 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55361 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55362 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}};
55363 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55364 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}};
55365 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55366 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}};
55367 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55368 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55369 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55370 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55371 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55372 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}};
55373 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55374 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}};
55375 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55376 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55377 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55379 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55380 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55381 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55382 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55383 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55384 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}};
55385 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55387 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}};
55388 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55389 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55390 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}};
55391 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}};
55392 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55400 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}};
55401 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55402 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}};
55403 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55406 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}};
55407 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55414 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}};
55415 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55420 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55421 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55429 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55430 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55431 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55432 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}};
55433 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55436 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55437 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55438 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55439 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55440 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55441 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55442 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55443 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55444 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55445 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55446 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55447 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55448 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55449 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55450 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55451 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55452 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55453 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55454 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55455 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55456 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55457 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55458 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55459 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55460 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55461 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55462 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55463 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55464 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}};
55465 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}};
55466 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55467 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55468 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55469 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55470 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55471 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55472 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55473 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}};
55474 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55475 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}};
55476 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55477 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55478 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55479 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55480
55481 static swig_cast_info *swig_cast_initial[] = {
55482 _swigc__p_buffer,
55483 _swigc__p_char,
55484 _swigc__p_form_ops_t,
55485 _swigc__p_int,
55486 _swigc__p_long,
55487 _swigc__p_unsigned_char,
55488 _swigc__p_unsigned_int,
55489 _swigc__p_unsigned_long,
55490 _swigc__p_wxANIHandler,
55491 _swigc__p_wxAcceleratorEntry,
55492 _swigc__p_wxAcceleratorTable,
55493 _swigc__p_wxActivateEvent,
55494 _swigc__p_wxAppTraits,
55495 _swigc__p_wxArrayString,
55496 _swigc__p_wxBMPHandler,
55497 _swigc__p_wxBitmap,
55498 _swigc__p_wxBoxSizer,
55499 _swigc__p_wxButton,
55500 _swigc__p_wxCURHandler,
55501 _swigc__p_wxCaret,
55502 _swigc__p_wxChildFocusEvent,
55503 _swigc__p_wxClipboardTextEvent,
55504 _swigc__p_wxCloseEvent,
55505 _swigc__p_wxColour,
55506 _swigc__p_wxCommandEvent,
55507 _swigc__p_wxContextMenuEvent,
55508 _swigc__p_wxControl,
55509 _swigc__p_wxControlWithItems,
55510 _swigc__p_wxCursor,
55511 _swigc__p_wxDC,
55512 _swigc__p_wxDateEvent,
55513 _swigc__p_wxDateTime,
55514 _swigc__p_wxDisplayChangedEvent,
55515 _swigc__p_wxDropFilesEvent,
55516 _swigc__p_wxDuplexMode,
55517 _swigc__p_wxEraseEvent,
55518 _swigc__p_wxEvent,
55519 _swigc__p_wxEventLoop,
55520 _swigc__p_wxEventLoopActivator,
55521 _swigc__p_wxEvtHandler,
55522 _swigc__p_wxFSFile,
55523 _swigc__p_wxFileSystem,
55524 _swigc__p_wxFileSystemHandler,
55525 _swigc__p_wxFlexGridSizer,
55526 _swigc__p_wxFocusEvent,
55527 _swigc__p_wxFont,
55528 _swigc__p_wxFrame,
55529 _swigc__p_wxGBPosition,
55530 _swigc__p_wxGBSizerItem,
55531 _swigc__p_wxGBSpan,
55532 _swigc__p_wxGIFHandler,
55533 _swigc__p_wxGridBagSizer,
55534 _swigc__p_wxGridSizer,
55535 _swigc__p_wxHelpEvent__Origin,
55536 _swigc__p_wxICOHandler,
55537 _swigc__p_wxIconizeEvent,
55538 _swigc__p_wxIdleEvent,
55539 _swigc__p_wxImage,
55540 _swigc__p_wxImageHandler,
55541 _swigc__p_wxImageHistogram,
55542 _swigc__p_wxImage_HSVValue,
55543 _swigc__p_wxImage_RGBValue,
55544 _swigc__p_wxIndividualLayoutConstraint,
55545 _swigc__p_wxInitDialogEvent,
55546 _swigc__p_wxInputStream,
55547 _swigc__p_wxInternetFSHandler,
55548 _swigc__p_wxItemContainer,
55549 _swigc__p_wxJPEGHandler,
55550 _swigc__p_wxKeyEvent,
55551 _swigc__p_wxLayoutConstraints,
55552 _swigc__p_wxMaximizeEvent,
55553 _swigc__p_wxMemoryFSHandler,
55554 _swigc__p_wxMenu,
55555 _swigc__p_wxMenuBar,
55556 _swigc__p_wxMenuBarBase,
55557 _swigc__p_wxMenuEvent,
55558 _swigc__p_wxMenuItem,
55559 _swigc__p_wxMouseCaptureChangedEvent,
55560 _swigc__p_wxMouseCaptureLostEvent,
55561 _swigc__p_wxMouseEvent,
55562 _swigc__p_wxMoveEvent,
55563 _swigc__p_wxNavigationKeyEvent,
55564 _swigc__p_wxNcPaintEvent,
55565 _swigc__p_wxNotifyEvent,
55566 _swigc__p_wxObject,
55567 _swigc__p_wxOutputStream,
55568 _swigc__p_wxPCXHandler,
55569 _swigc__p_wxPNGHandler,
55570 _swigc__p_wxPNMHandler,
55571 _swigc__p_wxPaintEvent,
55572 _swigc__p_wxPaletteChangedEvent,
55573 _swigc__p_wxPaperSize,
55574 _swigc__p_wxPoint,
55575 _swigc__p_wxPoint2D,
55576 _swigc__p_wxPropagateOnce,
55577 _swigc__p_wxPropagationDisabler,
55578 _swigc__p_wxPyApp,
55579 _swigc__p_wxPyCommandEvent,
55580 _swigc__p_wxPyDropTarget,
55581 _swigc__p_wxPyEvent,
55582 _swigc__p_wxPyFileSystemHandler,
55583 _swigc__p_wxPyImageHandler,
55584 _swigc__p_wxPyInputStream,
55585 _swigc__p_wxPySizer,
55586 _swigc__p_wxPyValidator,
55587 _swigc__p_wxQuantize,
55588 _swigc__p_wxQueryNewPaletteEvent,
55589 _swigc__p_wxRealPoint,
55590 _swigc__p_wxRect,
55591 _swigc__p_wxRegion,
55592 _swigc__p_wxScrollEvent,
55593 _swigc__p_wxScrollWinEvent,
55594 _swigc__p_wxSetCursorEvent,
55595 _swigc__p_wxShowEvent,
55596 _swigc__p_wxSize,
55597 _swigc__p_wxSizeEvent,
55598 _swigc__p_wxSizer,
55599 _swigc__p_wxSizerItem,
55600 _swigc__p_wxStaticBox,
55601 _swigc__p_wxStaticBoxSizer,
55602 _swigc__p_wxStdDialogButtonSizer,
55603 _swigc__p_wxSysColourChangedEvent,
55604 _swigc__p_wxTIFFHandler,
55605 _swigc__p_wxToolTip,
55606 _swigc__p_wxUpdateUIEvent,
55607 _swigc__p_wxValidator,
55608 _swigc__p_wxVisualAttributes,
55609 _swigc__p_wxWindow,
55610 _swigc__p_wxWindowCreateEvent,
55611 _swigc__p_wxWindowDestroyEvent,
55612 _swigc__p_wxXPMHandler,
55613 _swigc__p_wxZipFSHandler,
55614 };
55615
55616
55617 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55618
55619 static swig_const_info swig_const_table[] = {
55620 {0, 0, 0, 0.0, 0, 0}};
55621
55622 #ifdef __cplusplus
55623 }
55624 #endif
55625 /* -----------------------------------------------------------------------------
55626 * Type initialization:
55627 * This problem is tough by the requirement that no dynamic
55628 * memory is used. Also, since swig_type_info structures store pointers to
55629 * swig_cast_info structures and swig_cast_info structures store pointers back
55630 * to swig_type_info structures, we need some lookup code at initialization.
55631 * The idea is that swig generates all the structures that are needed.
55632 * The runtime then collects these partially filled structures.
55633 * The SWIG_InitializeModule function takes these initial arrays out of
55634 * swig_module, and does all the lookup, filling in the swig_module.types
55635 * array with the correct data and linking the correct swig_cast_info
55636 * structures together.
55637 *
55638 * The generated swig_type_info structures are assigned staticly to an initial
55639 * array. We just loop though that array, and handle each type individually.
55640 * First we lookup if this type has been already loaded, and if so, use the
55641 * loaded structure instead of the generated one. Then we have to fill in the
55642 * cast linked list. The cast data is initially stored in something like a
55643 * two-dimensional array. Each row corresponds to a type (there are the same
55644 * number of rows as there are in the swig_type_initial array). Each entry in
55645 * a column is one of the swig_cast_info structures for that type.
55646 * The cast_initial array is actually an array of arrays, because each row has
55647 * a variable number of columns. So to actually build the cast linked list,
55648 * we find the array of casts associated with the type, and loop through it
55649 * adding the casts to the list. The one last trick we need to do is making
55650 * sure the type pointer in the swig_cast_info struct is correct.
55651 *
55652 * First off, we lookup the cast->type name to see if it is already loaded.
55653 * There are three cases to handle:
55654 * 1) If the cast->type has already been loaded AND the type we are adding
55655 * casting info to has not been loaded (it is in this module), THEN we
55656 * replace the cast->type pointer with the type pointer that has already
55657 * been loaded.
55658 * 2) If BOTH types (the one we are adding casting info to, and the
55659 * cast->type) are loaded, THEN the cast info has already been loaded by
55660 * the previous module so we just ignore it.
55661 * 3) Finally, if cast->type has not already been loaded, then we add that
55662 * swig_cast_info to the linked list (because the cast->type) pointer will
55663 * be correct.
55664 * ----------------------------------------------------------------------------- */
55665
55666 #ifdef __cplusplus
55667 extern "C" {
55668 #if 0
55669 } /* c-mode */
55670 #endif
55671 #endif
55672
55673 #if 0
55674 #define SWIGRUNTIME_DEBUG
55675 #endif
55676
55677 SWIGRUNTIME void
55678 SWIG_InitializeModule(void *clientdata) {
55679 size_t i;
55680 swig_module_info *module_head;
55681 static int init_run = 0;
55682
55683 clientdata = clientdata;
55684
55685 if (init_run) return;
55686 init_run = 1;
55687
55688 /* Initialize the swig_module */
55689 swig_module.type_initial = swig_type_initial;
55690 swig_module.cast_initial = swig_cast_initial;
55691
55692 /* Try and load any already created modules */
55693 module_head = SWIG_GetModule(clientdata);
55694 if (module_head) {
55695 swig_module.next = module_head->next;
55696 module_head->next = &swig_module;
55697 } else {
55698 /* This is the first module loaded */
55699 swig_module.next = &swig_module;
55700 SWIG_SetModule(clientdata, &swig_module);
55701 }
55702
55703 /* Now work on filling in swig_module.types */
55704 #ifdef SWIGRUNTIME_DEBUG
55705 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55706 #endif
55707 for (i = 0; i < swig_module.size; ++i) {
55708 swig_type_info *type = 0;
55709 swig_type_info *ret;
55710 swig_cast_info *cast;
55711
55712 #ifdef SWIGRUNTIME_DEBUG
55713 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55714 #endif
55715
55716 /* if there is another module already loaded */
55717 if (swig_module.next != &swig_module) {
55718 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55719 }
55720 if (type) {
55721 /* Overwrite clientdata field */
55722 #ifdef SWIGRUNTIME_DEBUG
55723 printf("SWIG_InitializeModule: found type %s\n", type->name);
55724 #endif
55725 if (swig_module.type_initial[i]->clientdata) {
55726 type->clientdata = swig_module.type_initial[i]->clientdata;
55727 #ifdef SWIGRUNTIME_DEBUG
55728 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55729 #endif
55730 }
55731 } else {
55732 type = swig_module.type_initial[i];
55733 }
55734
55735 /* Insert casting types */
55736 cast = swig_module.cast_initial[i];
55737 while (cast->type) {
55738 /* Don't need to add information already in the list */
55739 ret = 0;
55740 #ifdef SWIGRUNTIME_DEBUG
55741 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55742 #endif
55743 if (swig_module.next != &swig_module) {
55744 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55745 #ifdef SWIGRUNTIME_DEBUG
55746 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55747 #endif
55748 }
55749 if (ret) {
55750 if (type == swig_module.type_initial[i]) {
55751 #ifdef SWIGRUNTIME_DEBUG
55752 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55753 #endif
55754 cast->type = ret;
55755 ret = 0;
55756 } else {
55757 /* Check for casting already in the list */
55758 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55759 #ifdef SWIGRUNTIME_DEBUG
55760 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55761 #endif
55762 if (!ocast) ret = 0;
55763 }
55764 }
55765
55766 if (!ret) {
55767 #ifdef SWIGRUNTIME_DEBUG
55768 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55769 #endif
55770 if (type->cast) {
55771 type->cast->prev = cast;
55772 cast->next = type->cast;
55773 }
55774 type->cast = cast;
55775 }
55776 cast++;
55777 }
55778 /* Set entry in modules->types array equal to the type */
55779 swig_module.types[i] = type;
55780 }
55781 swig_module.types[i] = 0;
55782
55783 #ifdef SWIGRUNTIME_DEBUG
55784 printf("**** SWIG_InitializeModule: Cast List ******\n");
55785 for (i = 0; i < swig_module.size; ++i) {
55786 int j = 0;
55787 swig_cast_info *cast = swig_module.cast_initial[i];
55788 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55789 while (cast->type) {
55790 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55791 cast++;
55792 ++j;
55793 }
55794 printf("---- Total casts: %d\n",j);
55795 }
55796 printf("**** SWIG_InitializeModule: Cast List ******\n");
55797 #endif
55798 }
55799
55800 /* This function will propagate the clientdata field of type to
55801 * any new swig_type_info structures that have been added into the list
55802 * of equivalent types. It is like calling
55803 * SWIG_TypeClientData(type, clientdata) a second time.
55804 */
55805 SWIGRUNTIME void
55806 SWIG_PropagateClientData(void) {
55807 size_t i;
55808 swig_cast_info *equiv;
55809 static int init_run = 0;
55810
55811 if (init_run) return;
55812 init_run = 1;
55813
55814 for (i = 0; i < swig_module.size; i++) {
55815 if (swig_module.types[i]->clientdata) {
55816 equiv = swig_module.types[i]->cast;
55817 while (equiv) {
55818 if (!equiv->converter) {
55819 if (equiv->type && !equiv->type->clientdata)
55820 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55821 }
55822 equiv = equiv->next;
55823 }
55824 }
55825 }
55826 }
55827
55828 #ifdef __cplusplus
55829 #if 0
55830 {
55831 /* c-mode */
55832 #endif
55833 }
55834 #endif
55835
55836
55837
55838 #ifdef __cplusplus
55839 extern "C" {
55840 #endif
55841
55842 /* Python-specific SWIG API */
55843 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55844 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55845 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55846
55847 /* -----------------------------------------------------------------------------
55848 * global variable support code.
55849 * ----------------------------------------------------------------------------- */
55850
55851 typedef struct swig_globalvar {
55852 char *name; /* Name of global variable */
55853 PyObject *(*get_attr)(void); /* Return the current value */
55854 int (*set_attr)(PyObject *); /* Set the value */
55855 struct swig_globalvar *next;
55856 } swig_globalvar;
55857
55858 typedef struct swig_varlinkobject {
55859 PyObject_HEAD
55860 swig_globalvar *vars;
55861 } swig_varlinkobject;
55862
55863 SWIGINTERN PyObject *
55864 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55865 return PyString_FromString("<Swig global variables>");
55866 }
55867
55868 SWIGINTERN PyObject *
55869 swig_varlink_str(swig_varlinkobject *v) {
55870 PyObject *str = PyString_FromString("(");
55871 swig_globalvar *var;
55872 for (var = v->vars; var; var=var->next) {
55873 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55874 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55875 }
55876 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55877 return str;
55878 }
55879
55880 SWIGINTERN int
55881 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55882 PyObject *str = swig_varlink_str(v);
55883 fprintf(fp,"Swig global variables ");
55884 fprintf(fp,"%s\n", PyString_AsString(str));
55885 Py_DECREF(str);
55886 return 0;
55887 }
55888
55889 SWIGINTERN void
55890 swig_varlink_dealloc(swig_varlinkobject *v) {
55891 swig_globalvar *var = v->vars;
55892 while (var) {
55893 swig_globalvar *n = var->next;
55894 free(var->name);
55895 free(var);
55896 var = n;
55897 }
55898 }
55899
55900 SWIGINTERN PyObject *
55901 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55902 PyObject *res = NULL;
55903 swig_globalvar *var = v->vars;
55904 while (var) {
55905 if (strcmp(var->name,n) == 0) {
55906 res = (*var->get_attr)();
55907 break;
55908 }
55909 var = var->next;
55910 }
55911 if (res == NULL && !PyErr_Occurred()) {
55912 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55913 }
55914 return res;
55915 }
55916
55917 SWIGINTERN int
55918 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55919 int res = 1;
55920 swig_globalvar *var = v->vars;
55921 while (var) {
55922 if (strcmp(var->name,n) == 0) {
55923 res = (*var->set_attr)(p);
55924 break;
55925 }
55926 var = var->next;
55927 }
55928 if (res == 1 && !PyErr_Occurred()) {
55929 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55930 }
55931 return res;
55932 }
55933
55934 SWIGINTERN PyTypeObject*
55935 swig_varlink_type(void) {
55936 static char varlink__doc__[] = "Swig var link object";
55937 static PyTypeObject varlink_type;
55938 static int type_init = 0;
55939 if (!type_init) {
55940 const PyTypeObject tmp
55941 = {
55942 PyObject_HEAD_INIT(NULL)
55943 0, /* Number of items in variable part (ob_size) */
55944 (char *)"swigvarlink", /* Type name (tp_name) */
55945 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55946 0, /* Itemsize (tp_itemsize) */
55947 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55948 (printfunc) swig_varlink_print, /* Print (tp_print) */
55949 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55950 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55951 0, /* tp_compare */
55952 (reprfunc) swig_varlink_repr, /* tp_repr */
55953 0, /* tp_as_number */
55954 0, /* tp_as_sequence */
55955 0, /* tp_as_mapping */
55956 0, /* tp_hash */
55957 0, /* tp_call */
55958 (reprfunc)swig_varlink_str, /* tp_str */
55959 0, /* tp_getattro */
55960 0, /* tp_setattro */
55961 0, /* tp_as_buffer */
55962 0, /* tp_flags */
55963 varlink__doc__, /* tp_doc */
55964 0, /* tp_traverse */
55965 0, /* tp_clear */
55966 0, /* tp_richcompare */
55967 0, /* tp_weaklistoffset */
55968 #if PY_VERSION_HEX >= 0x02020000
55969 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55970 #endif
55971 #if PY_VERSION_HEX >= 0x02030000
55972 0, /* tp_del */
55973 #endif
55974 #ifdef COUNT_ALLOCS
55975 0,0,0,0 /* tp_alloc -> tp_next */
55976 #endif
55977 };
55978 varlink_type = tmp;
55979 varlink_type.ob_type = &PyType_Type;
55980 type_init = 1;
55981 }
55982 return &varlink_type;
55983 }
55984
55985 /* Create a variable linking object for use later */
55986 SWIGINTERN PyObject *
55987 SWIG_Python_newvarlink(void) {
55988 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55989 if (result) {
55990 result->vars = 0;
55991 }
55992 return ((PyObject*) result);
55993 }
55994
55995 SWIGINTERN void
55996 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55997 swig_varlinkobject *v = (swig_varlinkobject *) p;
55998 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55999 if (gv) {
56000 size_t size = strlen(name)+1;
56001 gv->name = (char *)malloc(size);
56002 if (gv->name) {
56003 strncpy(gv->name,name,size);
56004 gv->get_attr = get_attr;
56005 gv->set_attr = set_attr;
56006 gv->next = v->vars;
56007 }
56008 }
56009 v->vars = gv;
56010 }
56011
56012 SWIGINTERN PyObject *
56013 SWIG_globals() {
56014 static PyObject *_SWIG_globals = 0;
56015 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56016 return _SWIG_globals;
56017 }
56018
56019 /* -----------------------------------------------------------------------------
56020 * constants/methods manipulation
56021 * ----------------------------------------------------------------------------- */
56022
56023 /* Install Constants */
56024 SWIGINTERN void
56025 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56026 PyObject *obj = 0;
56027 size_t i;
56028 for (i = 0; constants[i].type; ++i) {
56029 switch(constants[i].type) {
56030 case SWIG_PY_POINTER:
56031 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56032 break;
56033 case SWIG_PY_BINARY:
56034 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56035 break;
56036 default:
56037 obj = 0;
56038 break;
56039 }
56040 if (obj) {
56041 PyDict_SetItemString(d, constants[i].name, obj);
56042 Py_DECREF(obj);
56043 }
56044 }
56045 }
56046
56047 /* -----------------------------------------------------------------------------*/
56048 /* Fix SwigMethods to carry the callback ptrs when needed */
56049 /* -----------------------------------------------------------------------------*/
56050
56051 SWIGINTERN void
56052 SWIG_Python_FixMethods(PyMethodDef *methods,
56053 swig_const_info *const_table,
56054 swig_type_info **types,
56055 swig_type_info **types_initial) {
56056 size_t i;
56057 for (i = 0; methods[i].ml_name; ++i) {
56058 const char *c = methods[i].ml_doc;
56059 if (c && (c = strstr(c, "swig_ptr: "))) {
56060 int j;
56061 swig_const_info *ci = 0;
56062 const char *name = c + 10;
56063 for (j = 0; const_table[j].type; ++j) {
56064 if (strncmp(const_table[j].name, name,
56065 strlen(const_table[j].name)) == 0) {
56066 ci = &(const_table[j]);
56067 break;
56068 }
56069 }
56070 if (ci) {
56071 size_t shift = (ci->ptype) - types;
56072 swig_type_info *ty = types_initial[shift];
56073 size_t ldoc = (c - methods[i].ml_doc);
56074 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56075 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56076 if (ndoc) {
56077 char *buff = ndoc;
56078 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56079 if (ptr) {
56080 strncpy(buff, methods[i].ml_doc, ldoc);
56081 buff += ldoc;
56082 strncpy(buff, "swig_ptr: ", 10);
56083 buff += 10;
56084 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56085 methods[i].ml_doc = ndoc;
56086 }
56087 }
56088 }
56089 }
56090 }
56091 }
56092
56093 #ifdef __cplusplus
56094 }
56095 #endif
56096
56097 /* -----------------------------------------------------------------------------*
56098 * Partial Init method
56099 * -----------------------------------------------------------------------------*/
56100
56101 #ifdef __cplusplus
56102 extern "C"
56103 #endif
56104 SWIGEXPORT void SWIG_init(void) {
56105 PyObject *m, *d;
56106
56107 /* Fix SwigMethods to carry the callback ptrs when needed */
56108 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56109
56110 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56111 d = PyModule_GetDict(m);
56112
56113 SWIG_InitializeModule(0);
56114 SWIG_InstallConstants(d,swig_const_table);
56115
56116
56117
56118 #ifndef wxPyUSE_EXPORT
56119 // Make our API structure a CObject so other modules can import it
56120 // from this module.
56121 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56122 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56123 Py_XDECREF(cobj);
56124 #endif
56125
56126 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56127 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56128 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56129 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56130 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56131 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56132 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56133 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56134 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56135 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56136 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56137 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56138 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56139 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56140 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56141 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56142 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56143 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56144 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56145 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56146 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56147 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56148 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56149 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56150 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56151 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56152 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56153 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56154 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56155 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56156 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56157 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56158 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56159 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56160 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56161 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56162 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56163 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56164 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56165 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56166 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56167 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56168 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56169 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56170 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56171 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56172 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56173 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56174 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56175 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56176 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56177 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56178 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56179 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56180 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56181 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56182 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56183 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56184 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56185 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56186 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56187 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56188 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56189 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56190 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56191 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56192 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56193 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56194 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56195 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56196 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56197 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56198 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56199 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56200 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56201 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56202 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56203 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56204 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56205 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56206 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56207 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56208 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56209 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56210 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56211 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56212 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56213 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56214 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56215 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56216 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56217 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56218 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56219 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56220 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56221 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56222 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56223 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56224 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56225 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56226 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56227 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56228 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56229 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56230 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56231 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56232 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56233 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56234 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56235 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56236 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56237 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56238 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56239 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56240 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56241 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56242 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56243 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56244 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56245 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56246 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56247 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56248 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56249 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56250 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56251 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56252 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56253 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56254 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56255 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56256 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56257 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56258 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56259 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56260 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56261 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56262 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56263 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56264 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56265 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56266 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56267 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56268 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56269 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56270 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56271 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56272 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56273 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56274 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56275 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56276 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56277 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56278 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56279 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56280 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56281 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56282 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56283 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56284 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56285 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56286 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56287 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56288 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56289 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56290 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56291 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56292 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56293 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56294 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56295 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56296 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56297 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56298 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56299 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56300 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56301 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56302 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56303 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56304 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56305 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56306 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56307 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56308 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56309 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56310 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56311 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56312 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56313 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56314 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56315 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56316 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56317 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56318 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56319 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56320 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56321 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56322 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56323 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56324 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56325 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56326 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56327 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56328 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56329 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56330 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56331 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56332 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56333 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56334 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56335 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56336 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56337 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56338 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56339 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56340 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56341 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56342 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56343 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56344 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56345 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56346 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56347 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56348 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56349 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56350 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56351 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56352 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56353 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56354 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56355 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56356 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56357 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56358 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56359 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56360 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56361 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56362 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56363 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56364 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56365 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56366 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56367 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56368 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56369 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56370 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56371 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56372 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56373 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56374 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56375 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56376 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56377 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56378 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56379 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56380 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56381 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56382 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56383 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56384 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56385 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56386 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56387 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56388 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56389 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56390 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56391 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56392 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56393 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56394 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56395 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56396 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56397 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56398 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56399 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56400 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56401 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56402 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56403 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56404 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56405 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56406 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56407 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56408 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56409 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56410 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56411 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56412 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56413 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56414 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56415 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56416 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56417 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56418 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56419 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56420 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56421 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56422 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56423 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56424 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56425 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56426 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56427 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56428 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56429 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56430 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56431 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56432 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56433 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56434 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56435 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56436 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56437 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56438 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56439 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56440 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56441 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56442 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56443 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56444 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56445 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56446 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56447 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56448 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56449 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56450 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56451 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56452 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56453 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56454 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56455 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56456 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56457 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56458 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56459 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56460 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56461 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56462 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56463 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56464 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56465 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56466 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56467 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56468 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56469 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56470 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56471 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56472 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56473 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56474 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56475 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56476 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56477 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56478 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56479 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56480 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56481 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56482 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56483 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56484 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56485 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56486 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56487 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56488 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56489 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56490 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56491 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56492 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56493 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56494 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56495 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56496 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56497 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56498 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56499 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56500 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56501 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56502 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56503 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56504 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56505 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56506 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56507 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56508 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56509 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56510 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56511 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56512 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56513 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56514 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56515 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56516 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56517 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56518 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56519 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56520 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56521 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56522 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56523 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56524 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56525 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56526 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56527 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56528 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56529 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56530 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56531 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56532 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56533 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56534 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56535 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56536 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56537 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56538 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56539 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56540 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56541 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56542 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56543 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56544 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56545 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56546 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56547 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56548 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56549 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56550 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56551 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56552 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56553 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56554 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56555 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56556 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56557 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56558 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56559 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56560 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56561 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56562 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56563 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56564 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56565 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56566 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56567 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56568 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56569 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56570 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56571 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56572 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56573 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56574 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56575 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56576 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56577 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56578 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56579 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56580 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56581 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56582 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56583 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56584 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56585 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56586 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56587 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56588 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56589 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56590 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56591 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56592 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56593 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56594 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56595 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56596 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56597 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56598 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56599 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56600 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56601 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56602 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56603 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56604 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56605 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56606 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56607 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56608 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56609 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56610 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56611 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56612 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56613 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56614 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56615 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56616 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56617 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56618 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56619 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56620 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56621 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56622 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56623 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56624 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56625 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56626 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56627 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56628 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56629 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56630 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56631 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56632 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56633 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56634 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56635 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56636 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56637 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56638 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56639 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56640 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56641 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56642 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56643 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56644 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56645 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56646 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56647 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56648 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56649 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56650 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56651 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56652 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56653 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56654 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56655 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56656 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56657 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56658 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56659 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56660 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56661 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56662 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56663 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56664 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56665 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56666 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56667 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56668 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56669 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56670 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56671 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56672 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56673 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56674 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56675 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56676 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56677 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56678 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56679 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56680 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56681 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56682 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56683 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56684 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56685 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56686 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56687 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56688 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56689 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56690 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56691 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56692 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56693 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56694 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56695 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56696 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56697 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56698 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56699 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56700 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56701 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56702 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56703 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56704 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56705 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56706 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56707 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56708 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56709 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56710 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56711 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56712 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56713 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56714 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56715 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56716 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56717 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56718 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56719 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56720 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56721 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56722 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56723 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56724 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56725 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56726 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56727 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56728 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56729 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56730 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56731 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56732 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56733 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56734 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56735 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56736 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56737 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56738 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56739 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56740 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56741 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56742 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56743 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56744 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56745 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56746 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56747 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56748 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56749 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56750 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56751 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56752 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56753 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56754 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56755 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56756 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56757 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56758 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56759 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56760 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56761 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56762 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56763 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56764 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56765 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56766 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56767 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56768 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56769 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56770 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56771 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56772 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56773 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56774 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56775 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56776 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56777 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56778 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56779 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56780 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56781 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56782 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56783 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56784 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56785 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56786 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56787 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56788
56789 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56790
56791
56792 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56793
56794 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56795 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56796 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56797 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56798 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56799 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56800 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56801 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56802 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56803 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56804 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56805 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56806 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56807 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56808 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56809 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56810 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56811 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56812 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56813 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56814 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56815 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56816 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56817 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56818 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56819 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56820 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56821 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56822 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56823 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56824 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56825 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56826 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56827 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56828 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56829 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56830 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56831 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56832 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56833 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56834 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56835 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56836 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56837 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56838 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56839 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56840 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56841 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56842 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56843 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56844 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56845 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56846 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56847 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56848 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56849 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56850 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56851 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56852 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56853 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56854 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56855 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56856 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56857 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56858 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56859 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56860 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56861 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56862 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56863 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56864 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56865 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56866 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56867 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56868 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56869 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56870 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56871 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56872 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56873 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56874 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56875 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56876 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56877 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56878 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56879 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56880 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56881 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56882 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56883 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56884 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56885 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56886 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56887 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56888 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56889 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56890 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56891 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56892 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56893 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56894 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56895 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56896 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56897 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56898 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56899 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56900 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56901 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56902 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56903 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56904 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56905 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56906 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56907 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56908 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56909 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56910 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56911 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56912 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56913 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56914 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56915 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56916 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56917 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56918 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56919 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56920 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56921 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56922 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56923 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56924 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56925 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56926 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56927 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56928 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56929 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56930 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56931 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56932 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56933 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56934 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56935 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56936 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56937 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56938 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56939 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56940 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56941 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56942 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56943 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56944 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56945 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56946 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56947 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56948 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56949 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56950 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56951 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56952 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56953 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56954 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56955 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56956 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56957 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56958 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56959 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56960 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56961 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56962 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56963 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56964 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56965 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56966 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56967 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56968 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56969 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56970 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56971 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56972 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56973 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
56974 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56975 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56976 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56977 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56978 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56979 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56980 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56981 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56982 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56983 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56984 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56985 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56986 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56987 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56988 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56989 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56990 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56991 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56992 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56993 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56994 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56995 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56996 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56997 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56998 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56999 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57000 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57001 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57002 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57003 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57004 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57005 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57006
57007 // Initialize threading, some globals and such
57008 __wxPyPreStart(d);
57009
57010
57011 // Although these are defined in __version__ they need to be here too so
57012 // that an assert can be done to ensure that the wxPython and the wxWindows
57013 // versions match.
57014 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57015 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57016 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57017
57018 }
57019
wxWidgets (Impactor)