]> 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
Add support for aborting the worker thread
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3790 return wxPyTestDisplayAvailable();
3791 }
3792
3793 void wxApp_CleanUp() {
3794 __wxPyCleanup();
3795 }
3796
3797
3798 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3799
3800
3801
3802
3803
3804 SWIGINTERNINLINE PyObject *
3805 SWIG_FromCharPtr(const char *cptr)
3806 {
3807 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3808 }
3809
3810
3811 #if 0 // #ifdef __WXMAC__
3812
3813 // A dummy class that raises an exception if used...
3814 class wxEventLoop
3815 {
3816 public:
3817 wxEventLoop() { wxPyRaiseNotImplemented(); }
3818 int Run() { return 0; }
3819 void Exit(int rc = 0) {}
3820 bool Pending() const { return false; }
3821 bool Dispatch() { return false; }
3822 bool IsRunning() const { return false; }
3823 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3824 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3825 };
3826
3827 #else
3828
3829 #include <wx/evtloop.h>
3830
3831 #endif
3832
3833
3834
3835 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3836 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3837 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3838 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3839 wxWindowList& list = self->GetChildren();
3840 return wxPy_ConvertList(&list);
3841 }
3842 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863
3864 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3865 return wxWindow::FindWindowById(id, parent);
3866 }
3867
3868 wxWindow* wxFindWindowByName( const wxString& name,
3869 const wxWindow *parent = NULL ) {
3870 return wxWindow::FindWindowByName(name, parent);
3871 }
3872
3873 wxWindow* wxFindWindowByLabel( const wxString& label,
3874 const wxWindow *parent = NULL ) {
3875 return wxWindow::FindWindowByLabel(label, parent);
3876 }
3877
3878
3879 #ifdef __WXMSW__
3880 #include <wx/msw/private.h> // to get wxGetWindowId
3881 #endif
3882
3883
3884 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3885 #ifdef __WXMSW__
3886 WXHWND hWnd = (WXHWND)_hWnd;
3887 long id = wxGetWindowId(hWnd);
3888 wxWindow* win = new wxWindow;
3889 if (parent)
3890 parent->AddChild(win);
3891 win->SetEventHandler(win);
3892 win->SetHWND(hWnd);
3893 win->SetId(id);
3894 win->SubclassWin(hWnd);
3895 win->AdoptAttributesFromHWND();
3896 win->SetupColours();
3897 return win;
3898 #else
3899 wxPyRaiseNotImplemented();
3900 return NULL;
3901 #endif
3902 }
3903
3904
3905 PyObject* GetTopLevelWindows() {
3906 return wxPy_ConvertList(&wxTopLevelWindows);
3907 }
3908
3909
3910 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3911 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3913
3914 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3915
3916
3917 SWIGINTERNINLINE int
3918 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3919 {
3920 unsigned long v;
3921 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3922 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3923 return res;
3924 }
3925
3926 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3927 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3928 wxMenuItemList& list = self->GetMenuItems();
3929 return wxPy_ConvertList(&list);
3930 }
3931 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3932 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3933 static const wxString wxPyControlNameStr(wxControlNameStr);
3934 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3935 if (clientData) {
3936 wxPyClientData* data = new wxPyClientData(clientData);
3937 return self->Append(item, data);
3938 } else
3939 return self->Append(item);
3940 }
3941 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3942 if (clientData) {
3943 wxPyClientData* data = new wxPyClientData(clientData);
3944 return self->Insert(item, pos, data);
3945 } else
3946 return self->Insert(item, pos);
3947 }
3948 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3949 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3950 if (data) {
3951 Py_INCREF(data->m_obj);
3952 return data->m_obj;
3953 } else {
3954 Py_INCREF(Py_None);
3955 return Py_None;
3956 }
3957 }
3958 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 self->SetClientObject(n, data);
3961 }
3962
3963
3964 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3965 wxPyUserData* data = NULL;
3966 if ( userData ) {
3967 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3968 data = new wxPyUserData(userData);
3969 wxPyEndBlockThreads(blocked);
3970 }
3971 return new wxSizerItem(window, proportion, flag, border, data);
3972 }
3973 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3974 wxPyUserData* data = NULL;
3975 if ( userData ) {
3976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3977 data = new wxPyUserData(userData);
3978 wxPyEndBlockThreads(blocked);
3979 }
3980 return new wxSizerItem(width, height, proportion, flag, border, data);
3981 }
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(sizer, proportion, flag, border, data);
3990 }
3991
3992 SWIGINTERNINLINE PyObject *
3993 SWIG_From_float (float value)
3994 {
3995 return SWIG_From_double (value);
3996 }
3997
3998 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3999 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4000 if (data) {
4001 Py_INCREF(data->m_obj);
4002 return data->m_obj;
4003 } else {
4004 Py_INCREF(Py_None);
4005 return Py_None;
4006 }
4007 }
4008 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 self->SetUserData(data);
4016 }
4017
4018 // Figure out the type of the sizer item
4019
4020 struct wxPySizerItemInfo {
4021 wxPySizerItemInfo()
4022 : window(NULL), sizer(NULL), gotSize(false),
4023 size(wxDefaultSize), gotPos(false), pos(-1)
4024 {}
4025
4026 wxWindow* window;
4027 wxSizer* sizer;
4028 bool gotSize;
4029 wxSize size;
4030 bool gotPos;
4031 int pos;
4032 };
4033
4034 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4035
4036 wxPySizerItemInfo info;
4037 wxSize size;
4038 wxSize* sizePtr = &size;
4039
4040 // Find out what the type of the item is
4041 // try wxWindow
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4043 PyErr_Clear();
4044 info.window = NULL;
4045
4046 // try wxSizer
4047 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4048 PyErr_Clear();
4049 info.sizer = NULL;
4050
4051 // try wxSize or (w,h)
4052 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4053 info.size = *sizePtr;
4054 info.gotSize = true;
4055 }
4056
4057 // or a single int
4058 if (checkIdx && PyInt_Check(item)) {
4059 info.pos = PyInt_AsLong(item);
4060 info.gotPos = true;
4061 }
4062 }
4063 }
4064
4065 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4066 // no expected type, figure out what kind of error message to generate
4067 if ( !checkSize && !checkIdx )
4068 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4069 else if ( checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4071 else if ( !checkSize && checkIdx)
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4073 else
4074 // can this one happen?
4075 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4076 }
4077
4078 return info;
4079 }
4080
4081 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4082 if (!self->GetClientObject())
4083 self->SetClientObject(new wxPyOORClientData(_self));
4084 }
4085 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4086
4087 wxPyUserData* data = NULL;
4088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4089 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4090 if ( userData && (info.window || info.sizer || info.gotSize) )
4091 data = new wxPyUserData(userData);
4092 if ( info.sizer )
4093 PyObject_SetAttrString(item,"thisown",Py_False);
4094 wxPyEndBlockThreads(blocked);
4095
4096 // Now call the real Add method if a valid item type was found
4097 if ( info.window )
4098 return self->Add(info.window, proportion, flag, border, data);
4099 else if ( info.sizer )
4100 return self->Add(info.sizer, proportion, flag, border, data);
4101 else if (info.gotSize)
4102 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4103 proportion, flag, border, data);
4104 else
4105 return NULL;
4106 }
4107 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4108
4109 wxPyUserData* data = NULL;
4110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4111 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4112 if ( userData && (info.window || info.sizer || info.gotSize) )
4113 data = new wxPyUserData(userData);
4114 if ( info.sizer )
4115 PyObject_SetAttrString(item,"thisown",Py_False);
4116 wxPyEndBlockThreads(blocked);
4117
4118 // Now call the real Insert method if a valid item type was found
4119 if ( info.window )
4120 return self->Insert(before, info.window, proportion, flag, border, data);
4121 else if ( info.sizer )
4122 return self->Insert(before, info.sizer, proportion, flag, border, data);
4123 else if (info.gotSize)
4124 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4125 proportion, flag, border, data);
4126 else
4127 return NULL;
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Prepend method if a valid item type was found
4141 if ( info.window )
4142 return self->Prepend(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Prepend(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4153 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4154 wxPyEndBlockThreads(blocked);
4155 if ( info.window )
4156 return self->Remove(info.window);
4157 else if ( info.sizer )
4158 return self->Remove(info.sizer);
4159 else if ( info.gotPos )
4160 return self->Remove(info.pos);
4161 else
4162 return false;
4163 }
4164 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4166 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4167 wxPyEndBlockThreads(blocked);
4168 if ( info.window )
4169 return self->Detach(info.window);
4170 else if ( info.sizer )
4171 return self->Detach(info.sizer);
4172 else if ( info.gotPos )
4173 return self->Detach(info.pos);
4174 else
4175 return false;
4176 }
4177 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4180 wxPyEndBlockThreads(blocked);
4181 if ( info.window )
4182 return self->GetItem(info.window);
4183 else if ( info.sizer )
4184 return self->GetItem(info.sizer);
4185 else if ( info.gotPos )
4186 return self->GetItem(info.pos);
4187 else
4188 return NULL;
4189 }
4190 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4193 wxPyEndBlockThreads(blocked);
4194 if ( info.window )
4195 self->SetItemMinSize(info.window, size);
4196 else if ( info.sizer )
4197 self->SetItemMinSize(info.sizer, size);
4198 else if ( info.gotPos )
4199 self->SetItemMinSize(info.pos, size);
4200 }
4201 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4202 wxSizerItemList& list = self->GetChildren();
4203 return wxPy_ConvertList(&list);
4204 }
4205 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 return self->Show(info.window, show, recursive);
4211 else if ( info.sizer )
4212 return self->Show(info.sizer, show, recursive);
4213 else if ( info.gotPos )
4214 return self->Show(info.pos, show);
4215 else
4216 return false;
4217 }
4218 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4220 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4221 wxPyEndBlockThreads(blocked);
4222 if ( info.window )
4223 return self->IsShown(info.window);
4224 else if ( info.sizer )
4225 return self->IsShown(info.sizer);
4226 else if ( info.gotPos )
4227 return self->IsShown(info.pos);
4228 else
4229 return false;
4230 }
4231
4232 // See pyclasses.h
4233 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4234 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4235 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4236
4237
4238
4239
4240 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4241 {
4242 if (source == Py_None) {
4243 **obj = wxGBPosition(-1,-1);
4244 return true;
4245 }
4246 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4247 }
4248
4249 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4250 {
4251 if (source == Py_None) {
4252 **obj = wxGBSpan(-1,-1);
4253 return true;
4254 }
4255 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4256 }
4257
4258
4259 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4260 wxGBPosition temp, *obj = &temp;
4261 if ( other == Py_None ) return false;
4262 if ( ! wxGBPosition_helper(other, &obj) ) {
4263 PyErr_Clear();
4264 return false;
4265 }
4266 return self->operator==(*obj);
4267 }
4268 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4269 wxGBPosition temp, *obj = &temp;
4270 if ( other == Py_None ) return true;
4271 if ( ! wxGBPosition_helper(other, &obj)) {
4272 PyErr_Clear();
4273 return true;
4274 }
4275 return self->operator!=(*obj);
4276 }
4277 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4278 self->SetRow(row);
4279 self->SetCol(col);
4280 }
4281 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4283 PyObject* tup = PyTuple_New(2);
4284 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4285 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4286 wxPyEndBlockThreads(blocked);
4287 return tup;
4288 }
4289 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4290 wxGBSpan temp, *obj = &temp;
4291 if ( other == Py_None ) return false;
4292 if ( ! wxGBSpan_helper(other, &obj) ) {
4293 PyErr_Clear();
4294 return false;
4295 }
4296 return self->operator==(*obj);
4297 }
4298 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4299 wxGBSpan temp, *obj = &temp;
4300 if ( other == Py_None ) return true;
4301 if ( ! wxGBSpan_helper(other, &obj)) {
4302 PyErr_Clear();
4303 return true;
4304 }
4305 return self->operator!=(*obj);
4306 }
4307 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4308 self->SetRowspan(rowspan);
4309 self->SetColspan(colspan);
4310 }
4311 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 PyObject* tup = PyTuple_New(2);
4314 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4315 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4316 wxPyEndBlockThreads(blocked);
4317 return tup;
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(window, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4329 wxPyUserData* data = NULL;
4330 if ( userData ) {
4331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4332 data = new wxPyUserData(userData);
4333 wxPyEndBlockThreads(blocked);
4334 }
4335 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4347 int row, col;
4348 self->GetEndPos(row, col);
4349 return wxGBPosition(row, col);
4350 }
4351 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4352
4353 wxPyUserData* data = NULL;
4354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4355 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4356 if ( userData && (info.window || info.sizer || info.gotSize) )
4357 data = new wxPyUserData(userData);
4358 if ( info.sizer )
4359 PyObject_SetAttrString(item,"thisown",Py_False);
4360 wxPyEndBlockThreads(blocked);
4361
4362 // Now call the real Add method if a valid item type was found
4363 if ( info.window )
4364 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4365 else if ( info.sizer )
4366 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4367 else if (info.gotSize)
4368 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4369 pos, span, flag, border, data);
4370 return NULL;
4371 }
4372
4373
4374 #ifdef __cplusplus
4375 extern "C" {
4376 #endif
4377 SWIGINTERN int EmptyString_set(PyObject *) {
4378 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4379 return 1;
4380 }
4381
4382
4383 SWIGINTERN PyObject *EmptyString_get(void) {
4384 PyObject *pyobj = 0;
4385
4386 {
4387 #if wxUSE_UNICODE
4388 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4389 #else
4390 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #endif
4392 }
4393 return pyobj;
4394 }
4395
4396
4397 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4398 PyObject *resultobj = 0;
4399 wxObject *arg1 = (wxObject *) 0 ;
4400 wxString result;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4410 }
4411 arg1 = reinterpret_cast< wxObject * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = wxObject_GetClassName(arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 {
4419 #if wxUSE_UNICODE
4420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4421 #else
4422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4423 #endif
4424 }
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432 PyObject *resultobj = 0;
4433 wxObject *arg1 = (wxObject *) 0 ;
4434 void *argp1 = 0 ;
4435 int res1 = 0 ;
4436 PyObject *swig_obj[1] ;
4437
4438 if (!args) SWIG_fail;
4439 swig_obj[0] = args;
4440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4441 if (!SWIG_IsOK(res1)) {
4442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4443 }
4444 arg1 = reinterpret_cast< wxObject * >(argp1);
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 wxObject_Destroy(arg1);
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 resultobj = SWIG_Py_Void();
4452 return resultobj;
4453 fail:
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *obj;
4460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4461 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4462 return SWIG_Py_Void();
4463 }
4464
4465 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4466 PyObject *resultobj = 0;
4467 wxSize *arg1 = (wxSize *) 0 ;
4468 int arg2 ;
4469 void *argp1 = 0 ;
4470 int res1 = 0 ;
4471 int val2 ;
4472 int ecode2 = 0 ;
4473 PyObject *swig_obj[2] ;
4474
4475 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4477 if (!SWIG_IsOK(res1)) {
4478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4479 }
4480 arg1 = reinterpret_cast< wxSize * >(argp1);
4481 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4482 if (!SWIG_IsOK(ecode2)) {
4483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4484 }
4485 arg2 = static_cast< int >(val2);
4486 if (arg1) (arg1)->x = arg2;
4487
4488 resultobj = SWIG_Py_Void();
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4496 PyObject *resultobj = 0;
4497 wxSize *arg1 = (wxSize *) 0 ;
4498 int result;
4499 void *argp1 = 0 ;
4500 int res1 = 0 ;
4501 PyObject *swig_obj[1] ;
4502
4503 if (!args) SWIG_fail;
4504 swig_obj[0] = args;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4508 }
4509 arg1 = reinterpret_cast< wxSize * >(argp1);
4510 result = (int) ((arg1)->x);
4511 resultobj = SWIG_From_int(static_cast< int >(result));
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4519 PyObject *resultobj = 0;
4520 wxSize *arg1 = (wxSize *) 0 ;
4521 int arg2 ;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 int val2 ;
4525 int ecode2 = 0 ;
4526 PyObject *swig_obj[2] ;
4527
4528 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4532 }
4533 arg1 = reinterpret_cast< wxSize * >(argp1);
4534 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4535 if (!SWIG_IsOK(ecode2)) {
4536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4537 }
4538 arg2 = static_cast< int >(val2);
4539 if (arg1) (arg1)->y = arg2;
4540
4541 resultobj = SWIG_Py_Void();
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 PyObject *resultobj = 0;
4550 wxSize *arg1 = (wxSize *) 0 ;
4551 int result;
4552 void *argp1 = 0 ;
4553 int res1 = 0 ;
4554 PyObject *swig_obj[1] ;
4555
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4561 }
4562 arg1 = reinterpret_cast< wxSize * >(argp1);
4563 result = (int) ((arg1)->y);
4564 resultobj = SWIG_From_int(static_cast< int >(result));
4565 return resultobj;
4566 fail:
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4572 PyObject *resultobj = 0;
4573 int arg1 = (int) 0 ;
4574 int arg2 = (int) 0 ;
4575 wxSize *result = 0 ;
4576 int val1 ;
4577 int ecode1 = 0 ;
4578 int val2 ;
4579 int ecode2 = 0 ;
4580 PyObject * obj0 = 0 ;
4581 PyObject * obj1 = 0 ;
4582 char * kwnames[] = {
4583 (char *) "w",(char *) "h", NULL
4584 };
4585
4586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4587 if (obj0) {
4588 ecode1 = SWIG_AsVal_int(obj0, &val1);
4589 if (!SWIG_IsOK(ecode1)) {
4590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4591 }
4592 arg1 = static_cast< int >(val1);
4593 }
4594 if (obj1) {
4595 ecode2 = SWIG_AsVal_int(obj1, &val2);
4596 if (!SWIG_IsOK(ecode2)) {
4597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4598 }
4599 arg2 = static_cast< int >(val2);
4600 }
4601 {
4602 PyThreadState* __tstate = wxPyBeginAllowThreads();
4603 result = (wxSize *)new wxSize(arg1,arg2);
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4608 return resultobj;
4609 fail:
4610 return NULL;
4611 }
4612
4613
4614 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4615 PyObject *resultobj = 0;
4616 wxSize *arg1 = (wxSize *) 0 ;
4617 void *argp1 = 0 ;
4618 int res1 = 0 ;
4619 PyObject *swig_obj[1] ;
4620
4621 if (!args) SWIG_fail;
4622 swig_obj[0] = args;
4623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4626 }
4627 arg1 = reinterpret_cast< wxSize * >(argp1);
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 delete arg1;
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 resultobj = SWIG_Py_Void();
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 PyObject *arg2 = (PyObject *) 0 ;
4646 bool result;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "self",(char *) "other", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4657 if (!SWIG_IsOK(res1)) {
4658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4659 }
4660 arg1 = reinterpret_cast< wxSize * >(argp1);
4661 arg2 = obj1;
4662 {
4663 result = (bool)wxSize___eq__(arg1,arg2);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 {
4667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4668 }
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 wxSize *arg1 = (wxSize *) 0 ;
4678 PyObject *arg2 = (PyObject *) 0 ;
4679 bool result;
4680 void *argp1 = 0 ;
4681 int res1 = 0 ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 char * kwnames[] = {
4685 (char *) "self",(char *) "other", NULL
4686 };
4687
4688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4690 if (!SWIG_IsOK(res1)) {
4691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4692 }
4693 arg1 = reinterpret_cast< wxSize * >(argp1);
4694 arg2 = obj1;
4695 {
4696 result = (bool)wxSize___ne__(arg1,arg2);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 {
4700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4701 }
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 wxSize *arg1 = (wxSize *) 0 ;
4711 wxSize *arg2 = 0 ;
4712 wxSize result;
4713 void *argp1 = 0 ;
4714 int res1 = 0 ;
4715 wxSize temp2 ;
4716 PyObject * obj0 = 0 ;
4717 PyObject * obj1 = 0 ;
4718 char * kwnames[] = {
4719 (char *) "self",(char *) "sz", NULL
4720 };
4721
4722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4724 if (!SWIG_IsOK(res1)) {
4725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4726 }
4727 arg1 = reinterpret_cast< wxSize * >(argp1);
4728 {
4729 arg2 = &temp2;
4730 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4731 }
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (arg1)->operator +((wxSize const &)*arg2);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 wxSize *arg1 = (wxSize *) 0 ;
4748 wxSize *arg2 = 0 ;
4749 wxSize result;
4750 void *argp1 = 0 ;
4751 int res1 = 0 ;
4752 wxSize temp2 ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "self",(char *) "sz", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4761 if (!SWIG_IsOK(res1)) {
4762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4763 }
4764 arg1 = reinterpret_cast< wxSize * >(argp1);
4765 {
4766 arg2 = &temp2;
4767 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4768 }
4769 {
4770 PyThreadState* __tstate = wxPyBeginAllowThreads();
4771 result = (arg1)->operator -((wxSize const &)*arg2);
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj = 0;
4784 wxSize *arg1 = (wxSize *) 0 ;
4785 wxSize *arg2 = 0 ;
4786 void *argp1 = 0 ;
4787 int res1 = 0 ;
4788 wxSize temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char * kwnames[] = {
4792 (char *) "self",(char *) "sz", NULL
4793 };
4794
4795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4797 if (!SWIG_IsOK(res1)) {
4798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4799 }
4800 arg1 = reinterpret_cast< wxSize * >(argp1);
4801 {
4802 arg2 = &temp2;
4803 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4804 }
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 (arg1)->IncTo((wxSize const &)*arg2);
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_Py_Void();
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj = 0;
4820 wxSize *arg1 = (wxSize *) 0 ;
4821 wxSize *arg2 = 0 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char * kwnames[] = {
4828 (char *) "self",(char *) "sz", NULL
4829 };
4830
4831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4833 if (!SWIG_IsOK(res1)) {
4834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4835 }
4836 arg1 = reinterpret_cast< wxSize * >(argp1);
4837 {
4838 arg2 = &temp2;
4839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4840 }
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 (arg1)->DecTo((wxSize const &)*arg2);
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_Py_Void();
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj = 0;
4856 wxSize *arg1 = (wxSize *) 0 ;
4857 float arg2 ;
4858 float arg3 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 float val2 ;
4862 int ecode2 = 0 ;
4863 float val3 ;
4864 int ecode3 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 PyObject * obj2 = 0 ;
4868 char * kwnames[] = {
4869 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4870 };
4871
4872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4874 if (!SWIG_IsOK(res1)) {
4875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4876 }
4877 arg1 = reinterpret_cast< wxSize * >(argp1);
4878 ecode2 = SWIG_AsVal_float(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4881 }
4882 arg2 = static_cast< float >(val2);
4883 ecode3 = SWIG_AsVal_float(obj2, &val3);
4884 if (!SWIG_IsOK(ecode3)) {
4885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4886 }
4887 arg3 = static_cast< float >(val3);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 (arg1)->Scale(arg2,arg3);
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_Py_Void();
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 int arg2 ;
4905 int arg3 ;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 int val2 ;
4909 int ecode2 = 0 ;
4910 int val3 ;
4911 int ecode3 = 0 ;
4912 PyObject * obj0 = 0 ;
4913 PyObject * obj1 = 0 ;
4914 PyObject * obj2 = 0 ;
4915 char * kwnames[] = {
4916 (char *) "self",(char *) "w",(char *) "h", NULL
4917 };
4918
4919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4921 if (!SWIG_IsOK(res1)) {
4922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4923 }
4924 arg1 = reinterpret_cast< wxSize * >(argp1);
4925 ecode2 = SWIG_AsVal_int(obj1, &val2);
4926 if (!SWIG_IsOK(ecode2)) {
4927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4928 }
4929 arg2 = static_cast< int >(val2);
4930 ecode3 = SWIG_AsVal_int(obj2, &val3);
4931 if (!SWIG_IsOK(ecode3)) {
4932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4933 }
4934 arg3 = static_cast< int >(val3);
4935 {
4936 PyThreadState* __tstate = wxPyBeginAllowThreads();
4937 (arg1)->Set(arg2,arg3);
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 resultobj = SWIG_Py_Void();
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj = 0;
4950 wxSize *arg1 = (wxSize *) 0 ;
4951 int arg2 ;
4952 void *argp1 = 0 ;
4953 int res1 = 0 ;
4954 int val2 ;
4955 int ecode2 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 char * kwnames[] = {
4959 (char *) "self",(char *) "w", NULL
4960 };
4961
4962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4964 if (!SWIG_IsOK(res1)) {
4965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4966 }
4967 arg1 = reinterpret_cast< wxSize * >(argp1);
4968 ecode2 = SWIG_AsVal_int(obj1, &val2);
4969 if (!SWIG_IsOK(ecode2)) {
4970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4971 }
4972 arg2 = static_cast< int >(val2);
4973 {
4974 PyThreadState* __tstate = wxPyBeginAllowThreads();
4975 (arg1)->SetWidth(arg2);
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxSize *arg1 = (wxSize *) 0 ;
4989 int arg2 ;
4990 void *argp1 = 0 ;
4991 int res1 = 0 ;
4992 int val2 ;
4993 int ecode2 = 0 ;
4994 PyObject * obj0 = 0 ;
4995 PyObject * obj1 = 0 ;
4996 char * kwnames[] = {
4997 (char *) "self",(char *) "h", NULL
4998 };
4999
5000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5002 if (!SWIG_IsOK(res1)) {
5003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5004 }
5005 arg1 = reinterpret_cast< wxSize * >(argp1);
5006 ecode2 = SWIG_AsVal_int(obj1, &val2);
5007 if (!SWIG_IsOK(ecode2)) {
5008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5009 }
5010 arg2 = static_cast< int >(val2);
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 (arg1)->SetHeight(arg2);
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_Py_Void();
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 wxSize *arg1 = (wxSize *) 0 ;
5027 int result;
5028 void *argp1 = 0 ;
5029 int res1 = 0 ;
5030 PyObject *swig_obj[1] ;
5031
5032 if (!args) SWIG_fail;
5033 swig_obj[0] = args;
5034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5035 if (!SWIG_IsOK(res1)) {
5036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5037 }
5038 arg1 = reinterpret_cast< wxSize * >(argp1);
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (int)((wxSize const *)arg1)->GetWidth();
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 resultobj = SWIG_From_int(static_cast< int >(result));
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5053 PyObject *resultobj = 0;
5054 wxSize *arg1 = (wxSize *) 0 ;
5055 int result;
5056 void *argp1 = 0 ;
5057 int res1 = 0 ;
5058 PyObject *swig_obj[1] ;
5059
5060 if (!args) SWIG_fail;
5061 swig_obj[0] = args;
5062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)((wxSize const *)arg1)->GetHeight();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_From_int(static_cast< int >(result));
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 bool result;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087
5088 if (!args) SWIG_fail;
5089 swig_obj[0] = args;
5090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5091 if (!SWIG_IsOK(res1)) {
5092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5093 }
5094 arg1 = reinterpret_cast< wxSize * >(argp1);
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 wxSize *arg2 = 0 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 wxSize temp2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char * kwnames[] = {
5120 (char *) "self",(char *) "size", NULL
5121 };
5122
5123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5125 if (!SWIG_IsOK(res1)) {
5126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5127 }
5128 arg1 = reinterpret_cast< wxSize * >(argp1);
5129 {
5130 arg2 = &temp2;
5131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5132 }
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 (arg1)->SetDefaults((wxSize const &)*arg2);
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 PyObject *result = 0 ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 PyObject *swig_obj[1] ;
5153
5154 if (!args) SWIG_fail;
5155 swig_obj[0] = args;
5156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5157 if (!SWIG_IsOK(res1)) {
5158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5159 }
5160 arg1 = reinterpret_cast< wxSize * >(argp1);
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (PyObject *)wxSize_Get(arg1);
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 resultobj = result;
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 PyObject *obj;
5176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5177 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5178 return SWIG_Py_Void();
5179 }
5180
5181 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 return SWIG_Python_InitShadowInstance(args);
5183 }
5184
5185 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5186 PyObject *resultobj = 0;
5187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5188 double arg2 ;
5189 void *argp1 = 0 ;
5190 int res1 = 0 ;
5191 double val2 ;
5192 int ecode2 = 0 ;
5193 PyObject *swig_obj[2] ;
5194
5195 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5197 if (!SWIG_IsOK(res1)) {
5198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5199 }
5200 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5201 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5202 if (!SWIG_IsOK(ecode2)) {
5203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5204 }
5205 arg2 = static_cast< double >(val2);
5206 if (arg1) (arg1)->x = arg2;
5207
5208 resultobj = SWIG_Py_Void();
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5216 PyObject *resultobj = 0;
5217 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5218 double result;
5219 void *argp1 = 0 ;
5220 int res1 = 0 ;
5221 PyObject *swig_obj[1] ;
5222
5223 if (!args) SWIG_fail;
5224 swig_obj[0] = args;
5225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5226 if (!SWIG_IsOK(res1)) {
5227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5228 }
5229 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5230 result = (double) ((arg1)->x);
5231 resultobj = SWIG_From_double(static_cast< double >(result));
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5239 PyObject *resultobj = 0;
5240 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5241 double arg2 ;
5242 void *argp1 = 0 ;
5243 int res1 = 0 ;
5244 double val2 ;
5245 int ecode2 = 0 ;
5246 PyObject *swig_obj[2] ;
5247
5248 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5250 if (!SWIG_IsOK(res1)) {
5251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5252 }
5253 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5254 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5255 if (!SWIG_IsOK(ecode2)) {
5256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5257 }
5258 arg2 = static_cast< double >(val2);
5259 if (arg1) (arg1)->y = arg2;
5260
5261 resultobj = SWIG_Py_Void();
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5269 PyObject *resultobj = 0;
5270 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5271 double result;
5272 void *argp1 = 0 ;
5273 int res1 = 0 ;
5274 PyObject *swig_obj[1] ;
5275
5276 if (!args) SWIG_fail;
5277 swig_obj[0] = args;
5278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 result = (double) ((arg1)->y);
5284 resultobj = SWIG_From_double(static_cast< double >(result));
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 double arg1 = (double) 0.0 ;
5294 double arg2 = (double) 0.0 ;
5295 wxRealPoint *result = 0 ;
5296 double val1 ;
5297 int ecode1 = 0 ;
5298 double val2 ;
5299 int ecode2 = 0 ;
5300 PyObject * obj0 = 0 ;
5301 PyObject * obj1 = 0 ;
5302 char * kwnames[] = {
5303 (char *) "x",(char *) "y", NULL
5304 };
5305
5306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5307 if (obj0) {
5308 ecode1 = SWIG_AsVal_double(obj0, &val1);
5309 if (!SWIG_IsOK(ecode1)) {
5310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5311 }
5312 arg1 = static_cast< double >(val1);
5313 }
5314 if (obj1) {
5315 ecode2 = SWIG_AsVal_double(obj1, &val2);
5316 if (!SWIG_IsOK(ecode2)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5318 }
5319 arg2 = static_cast< double >(val2);
5320 }
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 PyObject *swig_obj[1] ;
5340
5341 if (!args) SWIG_fail;
5342 swig_obj[0] = args;
5343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5344 if (!SWIG_IsOK(res1)) {
5345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5346 }
5347 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 delete arg1;
5351
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 resultobj = SWIG_Py_Void();
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj = 0;
5364 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5365 PyObject *arg2 = (PyObject *) 0 ;
5366 bool result;
5367 void *argp1 = 0 ;
5368 int res1 = 0 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char * kwnames[] = {
5372 (char *) "self",(char *) "other", NULL
5373 };
5374
5375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5377 if (!SWIG_IsOK(res1)) {
5378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5379 }
5380 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5381 arg2 = obj1;
5382 {
5383 result = (bool)wxRealPoint___eq__(arg1,arg2);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 {
5387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5388 }
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj = 0;
5397 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5398 PyObject *arg2 = (PyObject *) 0 ;
5399 bool result;
5400 void *argp1 = 0 ;
5401 int res1 = 0 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char * kwnames[] = {
5405 (char *) "self",(char *) "other", NULL
5406 };
5407
5408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5412 }
5413 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5414 arg2 = obj1;
5415 {
5416 result = (bool)wxRealPoint___ne__(arg1,arg2);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5431 wxRealPoint *arg2 = 0 ;
5432 wxRealPoint result;
5433 void *argp1 = 0 ;
5434 int res1 = 0 ;
5435 wxRealPoint temp2 ;
5436 PyObject * obj0 = 0 ;
5437 PyObject * obj1 = 0 ;
5438 char * kwnames[] = {
5439 (char *) "self",(char *) "pt", NULL
5440 };
5441
5442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5444 if (!SWIG_IsOK(res1)) {
5445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5446 }
5447 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5455 wxPyEndAllowThreads(__tstate);
5456 if (PyErr_Occurred()) SWIG_fail;
5457 }
5458 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5459 return resultobj;
5460 fail:
5461 return NULL;
5462 }
5463
5464
5465 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5466 PyObject *resultobj = 0;
5467 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5468 wxRealPoint *arg2 = 0 ;
5469 wxRealPoint result;
5470 void *argp1 = 0 ;
5471 int res1 = 0 ;
5472 wxRealPoint temp2 ;
5473 PyObject * obj0 = 0 ;
5474 PyObject * obj1 = 0 ;
5475 char * kwnames[] = {
5476 (char *) "self",(char *) "pt", NULL
5477 };
5478
5479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5481 if (!SWIG_IsOK(res1)) {
5482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5483 }
5484 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5485 {
5486 arg2 = &temp2;
5487 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5488 }
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5503 PyObject *resultobj = 0;
5504 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5505 double arg2 ;
5506 double arg3 ;
5507 void *argp1 = 0 ;
5508 int res1 = 0 ;
5509 double val2 ;
5510 int ecode2 = 0 ;
5511 double val3 ;
5512 int ecode3 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 PyObject * obj2 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "x",(char *) "y", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 ecode2 = SWIG_AsVal_double(obj1, &val2);
5527 if (!SWIG_IsOK(ecode2)) {
5528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5529 }
5530 arg2 = static_cast< double >(val2);
5531 ecode3 = SWIG_AsVal_double(obj2, &val3);
5532 if (!SWIG_IsOK(ecode3)) {
5533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5534 }
5535 arg3 = static_cast< double >(val3);
5536 {
5537 PyThreadState* __tstate = wxPyBeginAllowThreads();
5538 wxRealPoint_Set(arg1,arg2,arg3);
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 resultobj = SWIG_Py_Void();
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5550 PyObject *resultobj = 0;
5551 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5552 PyObject *result = 0 ;
5553 void *argp1 = 0 ;
5554 int res1 = 0 ;
5555 PyObject *swig_obj[1] ;
5556
5557 if (!args) SWIG_fail;
5558 swig_obj[0] = args;
5559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5560 if (!SWIG_IsOK(res1)) {
5561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5562 }
5563 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (PyObject *)wxRealPoint_Get(arg1);
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = result;
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5578 PyObject *obj;
5579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5580 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5581 return SWIG_Py_Void();
5582 }
5583
5584 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 return SWIG_Python_InitShadowInstance(args);
5586 }
5587
5588 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590 wxPoint *arg1 = (wxPoint *) 0 ;
5591 int arg2 ;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 int val2 ;
5595 int ecode2 = 0 ;
5596 PyObject *swig_obj[2] ;
5597
5598 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5600 if (!SWIG_IsOK(res1)) {
5601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5602 }
5603 arg1 = reinterpret_cast< wxPoint * >(argp1);
5604 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5605 if (!SWIG_IsOK(ecode2)) {
5606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5607 }
5608 arg2 = static_cast< int >(val2);
5609 if (arg1) (arg1)->x = arg2;
5610
5611 resultobj = SWIG_Py_Void();
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5619 PyObject *resultobj = 0;
5620 wxPoint *arg1 = (wxPoint *) 0 ;
5621 int result;
5622 void *argp1 = 0 ;
5623 int res1 = 0 ;
5624 PyObject *swig_obj[1] ;
5625
5626 if (!args) SWIG_fail;
5627 swig_obj[0] = args;
5628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5629 if (!SWIG_IsOK(res1)) {
5630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5631 }
5632 arg1 = reinterpret_cast< wxPoint * >(argp1);
5633 result = (int) ((arg1)->x);
5634 resultobj = SWIG_From_int(static_cast< int >(result));
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 PyObject *resultobj = 0;
5643 wxPoint *arg1 = (wxPoint *) 0 ;
5644 int arg2 ;
5645 void *argp1 = 0 ;
5646 int res1 = 0 ;
5647 int val2 ;
5648 int ecode2 = 0 ;
5649 PyObject *swig_obj[2] ;
5650
5651 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5653 if (!SWIG_IsOK(res1)) {
5654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5655 }
5656 arg1 = reinterpret_cast< wxPoint * >(argp1);
5657 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5658 if (!SWIG_IsOK(ecode2)) {
5659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5660 }
5661 arg2 = static_cast< int >(val2);
5662 if (arg1) (arg1)->y = arg2;
5663
5664 resultobj = SWIG_Py_Void();
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5672 PyObject *resultobj = 0;
5673 wxPoint *arg1 = (wxPoint *) 0 ;
5674 int result;
5675 void *argp1 = 0 ;
5676 int res1 = 0 ;
5677 PyObject *swig_obj[1] ;
5678
5679 if (!args) SWIG_fail;
5680 swig_obj[0] = args;
5681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5682 if (!SWIG_IsOK(res1)) {
5683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5684 }
5685 arg1 = reinterpret_cast< wxPoint * >(argp1);
5686 result = (int) ((arg1)->y);
5687 resultobj = SWIG_From_int(static_cast< int >(result));
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj = 0;
5696 int arg1 = (int) 0 ;
5697 int arg2 = (int) 0 ;
5698 wxPoint *result = 0 ;
5699 int val1 ;
5700 int ecode1 = 0 ;
5701 int val2 ;
5702 int ecode2 = 0 ;
5703 PyObject * obj0 = 0 ;
5704 PyObject * obj1 = 0 ;
5705 char * kwnames[] = {
5706 (char *) "x",(char *) "y", NULL
5707 };
5708
5709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5710 if (obj0) {
5711 ecode1 = SWIG_AsVal_int(obj0, &val1);
5712 if (!SWIG_IsOK(ecode1)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5714 }
5715 arg1 = static_cast< int >(val1);
5716 }
5717 if (obj1) {
5718 ecode2 = SWIG_AsVal_int(obj1, &val2);
5719 if (!SWIG_IsOK(ecode2)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5721 }
5722 arg2 = static_cast< int >(val2);
5723 }
5724 {
5725 PyThreadState* __tstate = wxPyBeginAllowThreads();
5726 result = (wxPoint *)new wxPoint(arg1,arg2);
5727 wxPyEndAllowThreads(__tstate);
5728 if (PyErr_Occurred()) SWIG_fail;
5729 }
5730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 PyObject *swig_obj[1] ;
5743
5744 if (!args) SWIG_fail;
5745 swig_obj[0] = args;
5746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5747 if (!SWIG_IsOK(res1)) {
5748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5749 }
5750 arg1 = reinterpret_cast< wxPoint * >(argp1);
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 delete arg1;
5754
5755 wxPyEndAllowThreads(__tstate);
5756 if (PyErr_Occurred()) SWIG_fail;
5757 }
5758 resultobj = SWIG_Py_Void();
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5766 PyObject *resultobj = 0;
5767 wxPoint *arg1 = (wxPoint *) 0 ;
5768 PyObject *arg2 = (PyObject *) 0 ;
5769 bool result;
5770 void *argp1 = 0 ;
5771 int res1 = 0 ;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 char * kwnames[] = {
5775 (char *) "self",(char *) "other", NULL
5776 };
5777
5778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 arg2 = obj1;
5785 {
5786 result = (bool)wxPoint___eq__(arg1,arg2);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 {
5790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5791 }
5792 return resultobj;
5793 fail:
5794 return NULL;
5795 }
5796
5797
5798 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5799 PyObject *resultobj = 0;
5800 wxPoint *arg1 = (wxPoint *) 0 ;
5801 PyObject *arg2 = (PyObject *) 0 ;
5802 bool result;
5803 void *argp1 = 0 ;
5804 int res1 = 0 ;
5805 PyObject * obj0 = 0 ;
5806 PyObject * obj1 = 0 ;
5807 char * kwnames[] = {
5808 (char *) "self",(char *) "other", NULL
5809 };
5810
5811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5813 if (!SWIG_IsOK(res1)) {
5814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5815 }
5816 arg1 = reinterpret_cast< wxPoint * >(argp1);
5817 arg2 = obj1;
5818 {
5819 result = (bool)wxPoint___ne__(arg1,arg2);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5824 }
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj = 0;
5833 wxPoint *arg1 = (wxPoint *) 0 ;
5834 wxPoint *arg2 = 0 ;
5835 wxPoint result;
5836 void *argp1 = 0 ;
5837 int res1 = 0 ;
5838 wxPoint temp2 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 char * kwnames[] = {
5842 (char *) "self",(char *) "pt", NULL
5843 };
5844
5845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5847 if (!SWIG_IsOK(res1)) {
5848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5849 }
5850 arg1 = reinterpret_cast< wxPoint * >(argp1);
5851 {
5852 arg2 = &temp2;
5853 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5854 }
5855 {
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 result = (arg1)->operator +((wxPoint const &)*arg2);
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5862 return resultobj;
5863 fail:
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxPoint *arg1 = (wxPoint *) 0 ;
5871 wxPoint *arg2 = 0 ;
5872 wxPoint result;
5873 void *argp1 = 0 ;
5874 int res1 = 0 ;
5875 wxPoint temp2 ;
5876 PyObject * obj0 = 0 ;
5877 PyObject * obj1 = 0 ;
5878 char * kwnames[] = {
5879 (char *) "self",(char *) "pt", NULL
5880 };
5881
5882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5884 if (!SWIG_IsOK(res1)) {
5885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5886 }
5887 arg1 = reinterpret_cast< wxPoint * >(argp1);
5888 {
5889 arg2 = &temp2;
5890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5891 }
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 result = (arg1)->operator -((wxPoint const &)*arg2);
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj = 0;
5907 wxPoint *arg1 = (wxPoint *) 0 ;
5908 wxPoint *arg2 = 0 ;
5909 wxPoint *result = 0 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 wxPoint temp2 ;
5913 PyObject * obj0 = 0 ;
5914 PyObject * obj1 = 0 ;
5915 char * kwnames[] = {
5916 (char *) "self",(char *) "pt", NULL
5917 };
5918
5919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5921 if (!SWIG_IsOK(res1)) {
5922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5923 }
5924 arg1 = reinterpret_cast< wxPoint * >(argp1);
5925 {
5926 arg2 = &temp2;
5927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5928 }
5929 {
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 {
5932 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5933 result = (wxPoint *) &_result_ref;
5934 }
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 wxPoint *arg2 = 0 ;
5949 wxPoint *result = 0 ;
5950 void *argp1 = 0 ;
5951 int res1 = 0 ;
5952 wxPoint temp2 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "pt", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 {
5966 arg2 = &temp2;
5967 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5968 }
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 {
5972 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5973 result = (wxPoint *) &_result_ref;
5974 }
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj = 0;
5987 wxPoint *arg1 = (wxPoint *) 0 ;
5988 long arg2 ;
5989 long arg3 ;
5990 void *argp1 = 0 ;
5991 int res1 = 0 ;
5992 long val2 ;
5993 int ecode2 = 0 ;
5994 long val3 ;
5995 int ecode3 = 0 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 PyObject * obj2 = 0 ;
5999 char * kwnames[] = {
6000 (char *) "self",(char *) "x",(char *) "y", NULL
6001 };
6002
6003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6005 if (!SWIG_IsOK(res1)) {
6006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6007 }
6008 arg1 = reinterpret_cast< wxPoint * >(argp1);
6009 ecode2 = SWIG_AsVal_long(obj1, &val2);
6010 if (!SWIG_IsOK(ecode2)) {
6011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6012 }
6013 arg2 = static_cast< long >(val2);
6014 ecode3 = SWIG_AsVal_long(obj2, &val3);
6015 if (!SWIG_IsOK(ecode3)) {
6016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6017 }
6018 arg3 = static_cast< long >(val3);
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 wxPoint_Set(arg1,arg2,arg3);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 resultobj = SWIG_Py_Void();
6026 return resultobj;
6027 fail:
6028 return NULL;
6029 }
6030
6031
6032 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6033 PyObject *resultobj = 0;
6034 wxPoint *arg1 = (wxPoint *) 0 ;
6035 PyObject *result = 0 ;
6036 void *argp1 = 0 ;
6037 int res1 = 0 ;
6038 PyObject *swig_obj[1] ;
6039
6040 if (!args) SWIG_fail;
6041 swig_obj[0] = args;
6042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6043 if (!SWIG_IsOK(res1)) {
6044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6045 }
6046 arg1 = reinterpret_cast< wxPoint * >(argp1);
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (PyObject *)wxPoint_Get(arg1);
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 resultobj = result;
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6061 PyObject *obj;
6062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6063 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6064 return SWIG_Py_Void();
6065 }
6066
6067 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6068 return SWIG_Python_InitShadowInstance(args);
6069 }
6070
6071 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 int arg1 = (int) 0 ;
6074 int arg2 = (int) 0 ;
6075 int arg3 = (int) 0 ;
6076 int arg4 = (int) 0 ;
6077 wxRect *result = 0 ;
6078 int val1 ;
6079 int ecode1 = 0 ;
6080 int val2 ;
6081 int ecode2 = 0 ;
6082 int val3 ;
6083 int ecode3 = 0 ;
6084 int val4 ;
6085 int ecode4 = 0 ;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 PyObject * obj3 = 0 ;
6090 char * kwnames[] = {
6091 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6092 };
6093
6094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6095 if (obj0) {
6096 ecode1 = SWIG_AsVal_int(obj0, &val1);
6097 if (!SWIG_IsOK(ecode1)) {
6098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6099 }
6100 arg1 = static_cast< int >(val1);
6101 }
6102 if (obj1) {
6103 ecode2 = SWIG_AsVal_int(obj1, &val2);
6104 if (!SWIG_IsOK(ecode2)) {
6105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6106 }
6107 arg2 = static_cast< int >(val2);
6108 }
6109 if (obj2) {
6110 ecode3 = SWIG_AsVal_int(obj2, &val3);
6111 if (!SWIG_IsOK(ecode3)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6113 }
6114 arg3 = static_cast< int >(val3);
6115 }
6116 if (obj3) {
6117 ecode4 = SWIG_AsVal_int(obj3, &val4);
6118 if (!SWIG_IsOK(ecode4)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6120 }
6121 arg4 = static_cast< int >(val4);
6122 }
6123 {
6124 PyThreadState* __tstate = wxPyBeginAllowThreads();
6125 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj = 0;
6138 wxPoint *arg1 = 0 ;
6139 wxPoint *arg2 = 0 ;
6140 wxRect *result = 0 ;
6141 wxPoint temp1 ;
6142 wxPoint temp2 ;
6143 PyObject * obj0 = 0 ;
6144 PyObject * obj1 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "topLeft",(char *) "bottomRight", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6150 {
6151 arg1 = &temp1;
6152 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6153 }
6154 {
6155 arg2 = &temp2;
6156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj = 0;
6173 wxPoint *arg1 = 0 ;
6174 wxSize *arg2 = 0 ;
6175 wxRect *result = 0 ;
6176 wxPoint temp1 ;
6177 wxSize temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 char * kwnames[] = {
6181 (char *) "pos",(char *) "size", NULL
6182 };
6183
6184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6185 {
6186 arg1 = &temp1;
6187 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6188 }
6189 {
6190 arg2 = &temp2;
6191 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6192 }
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxSize *arg1 = 0 ;
6209 wxRect *result = 0 ;
6210 wxSize temp1 ;
6211 PyObject * obj0 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "size", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6217 {
6218 arg1 = &temp1;
6219 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6220 }
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6224 wxPyEndAllowThreads(__tstate);
6225 if (PyErr_Occurred()) SWIG_fail;
6226 }
6227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6235 PyObject *resultobj = 0;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 void *argp1 = 0 ;
6238 int res1 = 0 ;
6239 PyObject *swig_obj[1] ;
6240
6241 if (!args) SWIG_fail;
6242 swig_obj[0] = args;
6243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6244 if (!SWIG_IsOK(res1)) {
6245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6246 }
6247 arg1 = reinterpret_cast< wxRect * >(argp1);
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 delete arg1;
6251
6252 wxPyEndAllowThreads(__tstate);
6253 if (PyErr_Occurred()) SWIG_fail;
6254 }
6255 resultobj = SWIG_Py_Void();
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6263 PyObject *resultobj = 0;
6264 wxRect *arg1 = (wxRect *) 0 ;
6265 int result;
6266 void *argp1 = 0 ;
6267 int res1 = 0 ;
6268 PyObject *swig_obj[1] ;
6269
6270 if (!args) SWIG_fail;
6271 swig_obj[0] = args;
6272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6273 if (!SWIG_IsOK(res1)) {
6274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6275 }
6276 arg1 = reinterpret_cast< wxRect * >(argp1);
6277 {
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 result = (int)((wxRect const *)arg1)->GetX();
6280 wxPyEndAllowThreads(__tstate);
6281 if (PyErr_Occurred()) SWIG_fail;
6282 }
6283 resultobj = SWIG_From_int(static_cast< int >(result));
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj = 0;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int arg2 ;
6294 void *argp1 = 0 ;
6295 int res1 = 0 ;
6296 int val2 ;
6297 int ecode2 = 0 ;
6298 PyObject * obj0 = 0 ;
6299 PyObject * obj1 = 0 ;
6300 char * kwnames[] = {
6301 (char *) "self",(char *) "x", NULL
6302 };
6303
6304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6306 if (!SWIG_IsOK(res1)) {
6307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6308 }
6309 arg1 = reinterpret_cast< wxRect * >(argp1);
6310 ecode2 = SWIG_AsVal_int(obj1, &val2);
6311 if (!SWIG_IsOK(ecode2)) {
6312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6313 }
6314 arg2 = static_cast< int >(val2);
6315 {
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 (arg1)->SetX(arg2);
6318 wxPyEndAllowThreads(__tstate);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 resultobj = SWIG_Py_Void();
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6329 PyObject *resultobj = 0;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 int result;
6332 void *argp1 = 0 ;
6333 int res1 = 0 ;
6334 PyObject *swig_obj[1] ;
6335
6336 if (!args) SWIG_fail;
6337 swig_obj[0] = args;
6338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6339 if (!SWIG_IsOK(res1)) {
6340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6341 }
6342 arg1 = reinterpret_cast< wxRect * >(argp1);
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 result = (int)(arg1)->GetY();
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_From_int(static_cast< int >(result));
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6357 PyObject *resultobj = 0;
6358 wxRect *arg1 = (wxRect *) 0 ;
6359 int arg2 ;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 int val2 ;
6363 int ecode2 = 0 ;
6364 PyObject * obj0 = 0 ;
6365 PyObject * obj1 = 0 ;
6366 char * kwnames[] = {
6367 (char *) "self",(char *) "y", NULL
6368 };
6369
6370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 ecode2 = SWIG_AsVal_int(obj1, &val2);
6377 if (!SWIG_IsOK(ecode2)) {
6378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6379 }
6380 arg2 = static_cast< int >(val2);
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 (arg1)->SetY(arg2);
6384 wxPyEndAllowThreads(__tstate);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 resultobj = SWIG_Py_Void();
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395 PyObject *resultobj = 0;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 int result;
6398 void *argp1 = 0 ;
6399 int res1 = 0 ;
6400 PyObject *swig_obj[1] ;
6401
6402 if (!args) SWIG_fail;
6403 swig_obj[0] = args;
6404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6405 if (!SWIG_IsOK(res1)) {
6406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6407 }
6408 arg1 = reinterpret_cast< wxRect * >(argp1);
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (int)((wxRect const *)arg1)->GetWidth();
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 resultobj = SWIG_From_int(static_cast< int >(result));
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj = 0;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 int arg2 ;
6426 void *argp1 = 0 ;
6427 int res1 = 0 ;
6428 int val2 ;
6429 int ecode2 = 0 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char * kwnames[] = {
6433 (char *) "self",(char *) "w", NULL
6434 };
6435
6436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6438 if (!SWIG_IsOK(res1)) {
6439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6440 }
6441 arg1 = reinterpret_cast< wxRect * >(argp1);
6442 ecode2 = SWIG_AsVal_int(obj1, &val2);
6443 if (!SWIG_IsOK(ecode2)) {
6444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6445 }
6446 arg2 = static_cast< int >(val2);
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 (arg1)->SetWidth(arg2);
6450 wxPyEndAllowThreads(__tstate);
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 resultobj = SWIG_Py_Void();
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6461 PyObject *resultobj = 0;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int result;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 PyObject *swig_obj[1] ;
6467
6468 if (!args) SWIG_fail;
6469 swig_obj[0] = args;
6470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6471 if (!SWIG_IsOK(res1)) {
6472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6473 }
6474 arg1 = reinterpret_cast< wxRect * >(argp1);
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 result = (int)((wxRect const *)arg1)->GetHeight();
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_From_int(static_cast< int >(result));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj = 0;
6490 wxRect *arg1 = (wxRect *) 0 ;
6491 int arg2 ;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 int val2 ;
6495 int ecode2 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "h", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 ecode2 = SWIG_AsVal_int(obj1, &val2);
6509 if (!SWIG_IsOK(ecode2)) {
6510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6511 }
6512 arg2 = static_cast< int >(val2);
6513 {
6514 PyThreadState* __tstate = wxPyBeginAllowThreads();
6515 (arg1)->SetHeight(arg2);
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 resultobj = SWIG_Py_Void();
6520 return resultobj;
6521 fail:
6522 return NULL;
6523 }
6524
6525
6526 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6527 PyObject *resultobj = 0;
6528 wxRect *arg1 = (wxRect *) 0 ;
6529 wxPoint result;
6530 void *argp1 = 0 ;
6531 int res1 = 0 ;
6532 PyObject *swig_obj[1] ;
6533
6534 if (!args) SWIG_fail;
6535 swig_obj[0] = args;
6536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6539 }
6540 arg1 = reinterpret_cast< wxRect * >(argp1);
6541 {
6542 PyThreadState* __tstate = wxPyBeginAllowThreads();
6543 result = ((wxRect const *)arg1)->GetPosition();
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj = 0;
6556 wxRect *arg1 = (wxRect *) 0 ;
6557 wxPoint *arg2 = 0 ;
6558 void *argp1 = 0 ;
6559 int res1 = 0 ;
6560 wxPoint temp2 ;
6561 PyObject * obj0 = 0 ;
6562 PyObject * obj1 = 0 ;
6563 char * kwnames[] = {
6564 (char *) "self",(char *) "p", NULL
6565 };
6566
6567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6569 if (!SWIG_IsOK(res1)) {
6570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6571 }
6572 arg1 = reinterpret_cast< wxRect * >(argp1);
6573 {
6574 arg2 = &temp2;
6575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6576 }
6577 {
6578 PyThreadState* __tstate = wxPyBeginAllowThreads();
6579 (arg1)->SetPosition((wxPoint const &)*arg2);
6580 wxPyEndAllowThreads(__tstate);
6581 if (PyErr_Occurred()) SWIG_fail;
6582 }
6583 resultobj = SWIG_Py_Void();
6584 return resultobj;
6585 fail:
6586 return NULL;
6587 }
6588
6589
6590 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6591 PyObject *resultobj = 0;
6592 wxRect *arg1 = (wxRect *) 0 ;
6593 wxSize result;
6594 void *argp1 = 0 ;
6595 int res1 = 0 ;
6596 PyObject *swig_obj[1] ;
6597
6598 if (!args) SWIG_fail;
6599 swig_obj[0] = args;
6600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6601 if (!SWIG_IsOK(res1)) {
6602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6603 }
6604 arg1 = reinterpret_cast< wxRect * >(argp1);
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = ((wxRect const *)arg1)->GetSize();
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6612 return resultobj;
6613 fail:
6614 return NULL;
6615 }
6616
6617
6618 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6619 PyObject *resultobj = 0;
6620 wxRect *arg1 = (wxRect *) 0 ;
6621 wxSize *arg2 = 0 ;
6622 void *argp1 = 0 ;
6623 int res1 = 0 ;
6624 wxSize temp2 ;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 char * kwnames[] = {
6628 (char *) "self",(char *) "s", NULL
6629 };
6630
6631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 arg2 = &temp2;
6639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6640 }
6641 {
6642 PyThreadState* __tstate = wxPyBeginAllowThreads();
6643 (arg1)->SetSize((wxSize const &)*arg2);
6644 wxPyEndAllowThreads(__tstate);
6645 if (PyErr_Occurred()) SWIG_fail;
6646 }
6647 resultobj = SWIG_Py_Void();
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6655 PyObject *resultobj = 0;
6656 wxRect *arg1 = (wxRect *) 0 ;
6657 bool result;
6658 void *argp1 = 0 ;
6659 int res1 = 0 ;
6660 PyObject *swig_obj[1] ;
6661
6662 if (!args) SWIG_fail;
6663 swig_obj[0] = args;
6664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 result = (bool)((wxRect const *)arg1)->IsEmpty();
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 {
6676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6677 }
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6685 PyObject *resultobj = 0;
6686 wxRect *arg1 = (wxRect *) 0 ;
6687 wxPoint result;
6688 void *argp1 = 0 ;
6689 int res1 = 0 ;
6690 PyObject *swig_obj[1] ;
6691
6692 if (!args) SWIG_fail;
6693 swig_obj[0] = args;
6694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6695 if (!SWIG_IsOK(res1)) {
6696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6697 }
6698 arg1 = reinterpret_cast< wxRect * >(argp1);
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 result = ((wxRect const *)arg1)->GetTopLeft();
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj = 0;
6714 wxRect *arg1 = (wxRect *) 0 ;
6715 wxPoint *arg2 = 0 ;
6716 void *argp1 = 0 ;
6717 int res1 = 0 ;
6718 wxPoint temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char * kwnames[] = {
6722 (char *) "self",(char *) "p", NULL
6723 };
6724
6725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6727 if (!SWIG_IsOK(res1)) {
6728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6729 }
6730 arg1 = reinterpret_cast< wxRect * >(argp1);
6731 {
6732 arg2 = &temp2;
6733 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_Py_Void();
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6749 PyObject *resultobj = 0;
6750 wxRect *arg1 = (wxRect *) 0 ;
6751 wxPoint result;
6752 void *argp1 = 0 ;
6753 int res1 = 0 ;
6754 PyObject *swig_obj[1] ;
6755
6756 if (!args) SWIG_fail;
6757 swig_obj[0] = args;
6758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6759 if (!SWIG_IsOK(res1)) {
6760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6761 }
6762 arg1 = reinterpret_cast< wxRect * >(argp1);
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = ((wxRect const *)arg1)->GetBottomRight();
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj = 0;
6778 wxRect *arg1 = (wxRect *) 0 ;
6779 wxPoint *arg2 = 0 ;
6780 void *argp1 = 0 ;
6781 int res1 = 0 ;
6782 wxPoint temp2 ;
6783 PyObject * obj0 = 0 ;
6784 PyObject * obj1 = 0 ;
6785 char * kwnames[] = {
6786 (char *) "self",(char *) "p", NULL
6787 };
6788
6789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 arg2 = &temp2;
6797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_Py_Void();
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 wxRect *arg1 = (wxRect *) 0 ;
6815 wxPoint 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_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = ((wxRect const *)arg1)->GetTopRight();
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 wxPoint *arg2 = 0 ;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 wxPoint temp2 ;
6847 PyObject * obj0 = 0 ;
6848 PyObject * obj1 = 0 ;
6849 char * kwnames[] = {
6850 (char *) "self",(char *) "p", NULL
6851 };
6852
6853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 arg2 = &temp2;
6861 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6862 }
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 (arg1)->SetTopRight((wxPoint const &)*arg2);
6866 wxPyEndAllowThreads(__tstate);
6867 if (PyErr_Occurred()) SWIG_fail;
6868 }
6869 resultobj = SWIG_Py_Void();
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6877 PyObject *resultobj = 0;
6878 wxRect *arg1 = (wxRect *) 0 ;
6879 wxPoint result;
6880 void *argp1 = 0 ;
6881 int res1 = 0 ;
6882 PyObject *swig_obj[1] ;
6883
6884 if (!args) SWIG_fail;
6885 swig_obj[0] = args;
6886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6887 if (!SWIG_IsOK(res1)) {
6888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6889 }
6890 arg1 = reinterpret_cast< wxRect * >(argp1);
6891 {
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 result = ((wxRect const *)arg1)->GetBottomLeft();
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6905 PyObject *resultobj = 0;
6906 wxRect *arg1 = (wxRect *) 0 ;
6907 wxPoint *arg2 = 0 ;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 wxPoint temp2 ;
6911 PyObject * obj0 = 0 ;
6912 PyObject * obj1 = 0 ;
6913 char * kwnames[] = {
6914 (char *) "self",(char *) "p", NULL
6915 };
6916
6917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6919 if (!SWIG_IsOK(res1)) {
6920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6921 }
6922 arg1 = reinterpret_cast< wxRect * >(argp1);
6923 {
6924 arg2 = &temp2;
6925 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6926 }
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_Py_Void();
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 int result;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 PyObject *swig_obj[1] ;
6947
6948 if (!args) SWIG_fail;
6949 swig_obj[0] = args;
6950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6953 }
6954 arg1 = reinterpret_cast< wxRect * >(argp1);
6955 {
6956 PyThreadState* __tstate = wxPyBeginAllowThreads();
6957 result = (int)((wxRect const *)arg1)->GetLeft();
6958 wxPyEndAllowThreads(__tstate);
6959 if (PyErr_Occurred()) SWIG_fail;
6960 }
6961 resultobj = SWIG_From_int(static_cast< int >(result));
6962 return resultobj;
6963 fail:
6964 return NULL;
6965 }
6966
6967
6968 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6969 PyObject *resultobj = 0;
6970 wxRect *arg1 = (wxRect *) 0 ;
6971 int result;
6972 void *argp1 = 0 ;
6973 int res1 = 0 ;
6974 PyObject *swig_obj[1] ;
6975
6976 if (!args) SWIG_fail;
6977 swig_obj[0] = args;
6978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6979 if (!SWIG_IsOK(res1)) {
6980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6981 }
6982 arg1 = reinterpret_cast< wxRect * >(argp1);
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 result = (int)((wxRect const *)arg1)->GetTop();
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_From_int(static_cast< int >(result));
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6997 PyObject *resultobj = 0;
6998 wxRect *arg1 = (wxRect *) 0 ;
6999 int result;
7000 void *argp1 = 0 ;
7001 int res1 = 0 ;
7002 PyObject *swig_obj[1] ;
7003
7004 if (!args) SWIG_fail;
7005 swig_obj[0] = args;
7006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7007 if (!SWIG_IsOK(res1)) {
7008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7009 }
7010 arg1 = reinterpret_cast< wxRect * >(argp1);
7011 {
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (int)((wxRect const *)arg1)->GetBottom();
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_From_int(static_cast< int >(result));
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7025 PyObject *resultobj = 0;
7026 wxRect *arg1 = (wxRect *) 0 ;
7027 int result;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 PyObject *swig_obj[1] ;
7031
7032 if (!args) SWIG_fail;
7033 swig_obj[0] = args;
7034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 result = (int)((wxRect const *)arg1)->GetRight();
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 resultobj = SWIG_From_int(static_cast< int >(result));
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7053 PyObject *resultobj = 0;
7054 wxRect *arg1 = (wxRect *) 0 ;
7055 int arg2 ;
7056 void *argp1 = 0 ;
7057 int res1 = 0 ;
7058 int val2 ;
7059 int ecode2 = 0 ;
7060 PyObject * obj0 = 0 ;
7061 PyObject * obj1 = 0 ;
7062 char * kwnames[] = {
7063 (char *) "self",(char *) "left", NULL
7064 };
7065
7066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7068 if (!SWIG_IsOK(res1)) {
7069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7070 }
7071 arg1 = reinterpret_cast< wxRect * >(argp1);
7072 ecode2 = SWIG_AsVal_int(obj1, &val2);
7073 if (!SWIG_IsOK(ecode2)) {
7074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7075 }
7076 arg2 = static_cast< int >(val2);
7077 {
7078 PyThreadState* __tstate = wxPyBeginAllowThreads();
7079 (arg1)->SetLeft(arg2);
7080 wxPyEndAllowThreads(__tstate);
7081 if (PyErr_Occurred()) SWIG_fail;
7082 }
7083 resultobj = SWIG_Py_Void();
7084 return resultobj;
7085 fail:
7086 return NULL;
7087 }
7088
7089
7090 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7091 PyObject *resultobj = 0;
7092 wxRect *arg1 = (wxRect *) 0 ;
7093 int arg2 ;
7094 void *argp1 = 0 ;
7095 int res1 = 0 ;
7096 int val2 ;
7097 int ecode2 = 0 ;
7098 PyObject * obj0 = 0 ;
7099 PyObject * obj1 = 0 ;
7100 char * kwnames[] = {
7101 (char *) "self",(char *) "right", NULL
7102 };
7103
7104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7106 if (!SWIG_IsOK(res1)) {
7107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7108 }
7109 arg1 = reinterpret_cast< wxRect * >(argp1);
7110 ecode2 = SWIG_AsVal_int(obj1, &val2);
7111 if (!SWIG_IsOK(ecode2)) {
7112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7113 }
7114 arg2 = static_cast< int >(val2);
7115 {
7116 PyThreadState* __tstate = wxPyBeginAllowThreads();
7117 (arg1)->SetRight(arg2);
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_Py_Void();
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 int arg2 ;
7132 void *argp1 = 0 ;
7133 int res1 = 0 ;
7134 int val2 ;
7135 int ecode2 = 0 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "top", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 ecode2 = SWIG_AsVal_int(obj1, &val2);
7149 if (!SWIG_IsOK(ecode2)) {
7150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 (arg1)->SetTop(arg2);
7156 wxPyEndAllowThreads(__tstate);
7157 if (PyErr_Occurred()) SWIG_fail;
7158 }
7159 resultobj = SWIG_Py_Void();
7160 return resultobj;
7161 fail:
7162 return NULL;
7163 }
7164
7165
7166 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj = 0;
7168 wxRect *arg1 = (wxRect *) 0 ;
7169 int arg2 ;
7170 void *argp1 = 0 ;
7171 int res1 = 0 ;
7172 int val2 ;
7173 int ecode2 = 0 ;
7174 PyObject * obj0 = 0 ;
7175 PyObject * obj1 = 0 ;
7176 char * kwnames[] = {
7177 (char *) "self",(char *) "bottom", NULL
7178 };
7179
7180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7182 if (!SWIG_IsOK(res1)) {
7183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7184 }
7185 arg1 = reinterpret_cast< wxRect * >(argp1);
7186 ecode2 = SWIG_AsVal_int(obj1, &val2);
7187 if (!SWIG_IsOK(ecode2)) {
7188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7189 }
7190 arg2 = static_cast< int >(val2);
7191 {
7192 PyThreadState* __tstate = wxPyBeginAllowThreads();
7193 (arg1)->SetBottom(arg2);
7194 wxPyEndAllowThreads(__tstate);
7195 if (PyErr_Occurred()) SWIG_fail;
7196 }
7197 resultobj = SWIG_Py_Void();
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj = 0;
7206 wxRect *arg1 = (wxRect *) 0 ;
7207 int arg2 ;
7208 int arg3 ;
7209 wxRect *result = 0 ;
7210 void *argp1 = 0 ;
7211 int res1 = 0 ;
7212 int val2 ;
7213 int ecode2 = 0 ;
7214 int val3 ;
7215 int ecode3 = 0 ;
7216 PyObject * obj0 = 0 ;
7217 PyObject * obj1 = 0 ;
7218 PyObject * obj2 = 0 ;
7219 char * kwnames[] = {
7220 (char *) "self",(char *) "dx",(char *) "dy", NULL
7221 };
7222
7223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7225 if (!SWIG_IsOK(res1)) {
7226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7227 }
7228 arg1 = reinterpret_cast< wxRect * >(argp1);
7229 ecode2 = SWIG_AsVal_int(obj1, &val2);
7230 if (!SWIG_IsOK(ecode2)) {
7231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7232 }
7233 arg2 = static_cast< int >(val2);
7234 ecode3 = SWIG_AsVal_int(obj2, &val3);
7235 if (!SWIG_IsOK(ecode3)) {
7236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7237 }
7238 arg3 = static_cast< int >(val3);
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 {
7242 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7243 result = (wxRect *) &_result_ref;
7244 }
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj = 0;
7257 wxRect *arg1 = (wxRect *) 0 ;
7258 int arg2 ;
7259 int arg3 ;
7260 wxRect *result = 0 ;
7261 void *argp1 = 0 ;
7262 int res1 = 0 ;
7263 int val2 ;
7264 int ecode2 = 0 ;
7265 int val3 ;
7266 int ecode3 = 0 ;
7267 PyObject * obj0 = 0 ;
7268 PyObject * obj1 = 0 ;
7269 PyObject * obj2 = 0 ;
7270 char * kwnames[] = {
7271 (char *) "self",(char *) "dx",(char *) "dy", NULL
7272 };
7273
7274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7276 if (!SWIG_IsOK(res1)) {
7277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7278 }
7279 arg1 = reinterpret_cast< wxRect * >(argp1);
7280 ecode2 = SWIG_AsVal_int(obj1, &val2);
7281 if (!SWIG_IsOK(ecode2)) {
7282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7283 }
7284 arg2 = static_cast< int >(val2);
7285 ecode3 = SWIG_AsVal_int(obj2, &val3);
7286 if (!SWIG_IsOK(ecode3)) {
7287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7288 }
7289 arg3 = static_cast< int >(val3);
7290 {
7291 PyThreadState* __tstate = wxPyBeginAllowThreads();
7292 {
7293 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7294 result = (wxRect *) &_result_ref;
7295 }
7296 wxPyEndAllowThreads(__tstate);
7297 if (PyErr_Occurred()) SWIG_fail;
7298 }
7299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7300 return resultobj;
7301 fail:
7302 return NULL;
7303 }
7304
7305
7306 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7307 PyObject *resultobj = 0;
7308 wxRect *arg1 = (wxRect *) 0 ;
7309 int arg2 ;
7310 int arg3 ;
7311 void *argp1 = 0 ;
7312 int res1 = 0 ;
7313 int val2 ;
7314 int ecode2 = 0 ;
7315 int val3 ;
7316 int ecode3 = 0 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 PyObject * obj2 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "dx",(char *) "dy", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 ecode2 = SWIG_AsVal_int(obj1, &val2);
7331 if (!SWIG_IsOK(ecode2)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7333 }
7334 arg2 = static_cast< int >(val2);
7335 ecode3 = SWIG_AsVal_int(obj2, &val3);
7336 if (!SWIG_IsOK(ecode3)) {
7337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7338 }
7339 arg3 = static_cast< int >(val3);
7340 {
7341 PyThreadState* __tstate = wxPyBeginAllowThreads();
7342 (arg1)->Offset(arg2,arg3);
7343 wxPyEndAllowThreads(__tstate);
7344 if (PyErr_Occurred()) SWIG_fail;
7345 }
7346 resultobj = SWIG_Py_Void();
7347 return resultobj;
7348 fail:
7349 return NULL;
7350 }
7351
7352
7353 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj = 0;
7355 wxRect *arg1 = (wxRect *) 0 ;
7356 wxPoint *arg2 = 0 ;
7357 void *argp1 = 0 ;
7358 int res1 = 0 ;
7359 wxPoint temp2 ;
7360 PyObject * obj0 = 0 ;
7361 PyObject * obj1 = 0 ;
7362 char * kwnames[] = {
7363 (char *) "self",(char *) "pt", NULL
7364 };
7365
7366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7370 }
7371 arg1 = reinterpret_cast< wxRect * >(argp1);
7372 {
7373 arg2 = &temp2;
7374 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7375 }
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 (arg1)->Offset((wxPoint const &)*arg2);
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 resultobj = SWIG_Py_Void();
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj = 0;
7391 wxRect *arg1 = (wxRect *) 0 ;
7392 wxRect *arg2 = 0 ;
7393 wxRect result;
7394 void *argp1 = 0 ;
7395 int res1 = 0 ;
7396 wxRect temp2 ;
7397 PyObject * obj0 = 0 ;
7398 PyObject * obj1 = 0 ;
7399 char * kwnames[] = {
7400 (char *) "self",(char *) "rect", NULL
7401 };
7402
7403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7407 }
7408 arg1 = reinterpret_cast< wxRect * >(argp1);
7409 {
7410 arg2 = &temp2;
7411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7412 }
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (arg1)->Intersect((wxRect const &)*arg2);
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 wxRect *arg2 = 0 ;
7430 wxRect result;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 wxRect temp2 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "rect", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 {
7447 arg2 = &temp2;
7448 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7449 }
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (arg1)->Union((wxRect const &)*arg2);
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 wxRect *arg2 = 0 ;
7467 wxRect result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 wxRect temp2 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 char * kwnames[] = {
7474 (char *) "self",(char *) "rect", NULL
7475 };
7476
7477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7479 if (!SWIG_IsOK(res1)) {
7480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7481 }
7482 arg1 = reinterpret_cast< wxRect * >(argp1);
7483 {
7484 arg2 = &temp2;
7485 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7486 }
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj = 0;
7502 wxRect *arg1 = (wxRect *) 0 ;
7503 wxRect *arg2 = 0 ;
7504 wxRect *result = 0 ;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 wxRect temp2 ;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "rect", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7518 }
7519 arg1 = reinterpret_cast< wxRect * >(argp1);
7520 {
7521 arg2 = &temp2;
7522 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7523 }
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 {
7527 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7528 result = (wxRect *) &_result_ref;
7529 }
7530 wxPyEndAllowThreads(__tstate);
7531 if (PyErr_Occurred()) SWIG_fail;
7532 }
7533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7534 return resultobj;
7535 fail:
7536 return NULL;
7537 }
7538
7539
7540 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7541 PyObject *resultobj = 0;
7542 wxRect *arg1 = (wxRect *) 0 ;
7543 PyObject *arg2 = (PyObject *) 0 ;
7544 bool result;
7545 void *argp1 = 0 ;
7546 int res1 = 0 ;
7547 PyObject * obj0 = 0 ;
7548 PyObject * obj1 = 0 ;
7549 char * kwnames[] = {
7550 (char *) "self",(char *) "other", NULL
7551 };
7552
7553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7557 }
7558 arg1 = reinterpret_cast< wxRect * >(argp1);
7559 arg2 = obj1;
7560 {
7561 result = (bool)wxRect___eq__(arg1,arg2);
7562 if (PyErr_Occurred()) SWIG_fail;
7563 }
7564 {
7565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7566 }
7567 return resultobj;
7568 fail:
7569 return NULL;
7570 }
7571
7572
7573 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7574 PyObject *resultobj = 0;
7575 wxRect *arg1 = (wxRect *) 0 ;
7576 PyObject *arg2 = (PyObject *) 0 ;
7577 bool result;
7578 void *argp1 = 0 ;
7579 int res1 = 0 ;
7580 PyObject * obj0 = 0 ;
7581 PyObject * obj1 = 0 ;
7582 char * kwnames[] = {
7583 (char *) "self",(char *) "other", NULL
7584 };
7585
7586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7588 if (!SWIG_IsOK(res1)) {
7589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7590 }
7591 arg1 = reinterpret_cast< wxRect * >(argp1);
7592 arg2 = obj1;
7593 {
7594 result = (bool)wxRect___ne__(arg1,arg2);
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_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj = 0;
7608 wxRect *arg1 = (wxRect *) 0 ;
7609 int arg2 ;
7610 int arg3 ;
7611 bool result;
7612 void *argp1 = 0 ;
7613 int res1 = 0 ;
7614 int val2 ;
7615 int ecode2 = 0 ;
7616 int val3 ;
7617 int ecode3 = 0 ;
7618 PyObject * obj0 = 0 ;
7619 PyObject * obj1 = 0 ;
7620 PyObject * obj2 = 0 ;
7621 char * kwnames[] = {
7622 (char *) "self",(char *) "x",(char *) "y", NULL
7623 };
7624
7625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7627 if (!SWIG_IsOK(res1)) {
7628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7629 }
7630 arg1 = reinterpret_cast< wxRect * >(argp1);
7631 ecode2 = SWIG_AsVal_int(obj1, &val2);
7632 if (!SWIG_IsOK(ecode2)) {
7633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7634 }
7635 arg2 = static_cast< int >(val2);
7636 ecode3 = SWIG_AsVal_int(obj2, &val3);
7637 if (!SWIG_IsOK(ecode3)) {
7638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7639 }
7640 arg3 = static_cast< int >(val3);
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 {
7648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7649 }
7650 return resultobj;
7651 fail:
7652 return NULL;
7653 }
7654
7655
7656 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7657 PyObject *resultobj = 0;
7658 wxRect *arg1 = (wxRect *) 0 ;
7659 wxPoint *arg2 = 0 ;
7660 bool result;
7661 void *argp1 = 0 ;
7662 int res1 = 0 ;
7663 wxPoint temp2 ;
7664 PyObject * obj0 = 0 ;
7665 PyObject * obj1 = 0 ;
7666 char * kwnames[] = {
7667 (char *) "self",(char *) "pt", NULL
7668 };
7669
7670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7672 if (!SWIG_IsOK(res1)) {
7673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7674 }
7675 arg1 = reinterpret_cast< wxRect * >(argp1);
7676 {
7677 arg2 = &temp2;
7678 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7679 }
7680 {
7681 PyThreadState* __tstate = wxPyBeginAllowThreads();
7682 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 {
7687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7688 }
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj = 0;
7697 wxRect *arg1 = (wxRect *) 0 ;
7698 wxRect *arg2 = 0 ;
7699 bool result;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 wxRect temp2 ;
7703 PyObject * obj0 = 0 ;
7704 PyObject * obj1 = 0 ;
7705 char * kwnames[] = {
7706 (char *) "self",(char *) "rect", NULL
7707 };
7708
7709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 {
7716 arg2 = &temp2;
7717 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7718 }
7719 {
7720 PyThreadState* __tstate = wxPyBeginAllowThreads();
7721 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj = 0;
7736 wxRect *arg1 = (wxRect *) 0 ;
7737 wxRect *arg2 = 0 ;
7738 bool result;
7739 void *argp1 = 0 ;
7740 int res1 = 0 ;
7741 wxRect temp2 ;
7742 PyObject * obj0 = 0 ;
7743 PyObject * obj1 = 0 ;
7744 char * kwnames[] = {
7745 (char *) "self",(char *) "rect", NULL
7746 };
7747
7748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 {
7755 arg2 = &temp2;
7756 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7757 }
7758 {
7759 PyThreadState* __tstate = wxPyBeginAllowThreads();
7760 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7761 wxPyEndAllowThreads(__tstate);
7762 if (PyErr_Occurred()) SWIG_fail;
7763 }
7764 {
7765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7766 }
7767 return resultobj;
7768 fail:
7769 return NULL;
7770 }
7771
7772
7773 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7774 PyObject *resultobj = 0;
7775 wxRect *arg1 = (wxRect *) 0 ;
7776 wxRect *arg2 = 0 ;
7777 int arg3 = (int) wxBOTH ;
7778 wxRect result;
7779 void *argp1 = 0 ;
7780 int res1 = 0 ;
7781 wxRect temp2 ;
7782 int val3 ;
7783 int ecode3 = 0 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 PyObject * obj2 = 0 ;
7787 char * kwnames[] = {
7788 (char *) "self",(char *) "r",(char *) "dir", NULL
7789 };
7790
7791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7795 }
7796 arg1 = reinterpret_cast< wxRect * >(argp1);
7797 {
7798 arg2 = &temp2;
7799 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7800 }
7801 if (obj2) {
7802 ecode3 = SWIG_AsVal_int(obj2, &val3);
7803 if (!SWIG_IsOK(ecode3)) {
7804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7805 }
7806 arg3 = static_cast< int >(val3);
7807 }
7808 {
7809 PyThreadState* __tstate = wxPyBeginAllowThreads();
7810 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7811 wxPyEndAllowThreads(__tstate);
7812 if (PyErr_Occurred()) SWIG_fail;
7813 }
7814 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7822 PyObject *resultobj = 0;
7823 wxRect *arg1 = (wxRect *) 0 ;
7824 int arg2 ;
7825 void *argp1 = 0 ;
7826 int res1 = 0 ;
7827 int val2 ;
7828 int ecode2 = 0 ;
7829 PyObject *swig_obj[2] ;
7830
7831 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7833 if (!SWIG_IsOK(res1)) {
7834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7835 }
7836 arg1 = reinterpret_cast< wxRect * >(argp1);
7837 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7838 if (!SWIG_IsOK(ecode2)) {
7839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7840 }
7841 arg2 = static_cast< int >(val2);
7842 if (arg1) (arg1)->x = arg2;
7843
7844 resultobj = SWIG_Py_Void();
7845 return resultobj;
7846 fail:
7847 return NULL;
7848 }
7849
7850
7851 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7852 PyObject *resultobj = 0;
7853 wxRect *arg1 = (wxRect *) 0 ;
7854 int result;
7855 void *argp1 = 0 ;
7856 int res1 = 0 ;
7857 PyObject *swig_obj[1] ;
7858
7859 if (!args) SWIG_fail;
7860 swig_obj[0] = args;
7861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7862 if (!SWIG_IsOK(res1)) {
7863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7864 }
7865 arg1 = reinterpret_cast< wxRect * >(argp1);
7866 result = (int) ((arg1)->x);
7867 resultobj = SWIG_From_int(static_cast< int >(result));
7868 return resultobj;
7869 fail:
7870 return NULL;
7871 }
7872
7873
7874 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7875 PyObject *resultobj = 0;
7876 wxRect *arg1 = (wxRect *) 0 ;
7877 int arg2 ;
7878 void *argp1 = 0 ;
7879 int res1 = 0 ;
7880 int val2 ;
7881 int ecode2 = 0 ;
7882 PyObject *swig_obj[2] ;
7883
7884 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7886 if (!SWIG_IsOK(res1)) {
7887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7888 }
7889 arg1 = reinterpret_cast< wxRect * >(argp1);
7890 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7891 if (!SWIG_IsOK(ecode2)) {
7892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7893 }
7894 arg2 = static_cast< int >(val2);
7895 if (arg1) (arg1)->y = arg2;
7896
7897 resultobj = SWIG_Py_Void();
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7905 PyObject *resultobj = 0;
7906 wxRect *arg1 = (wxRect *) 0 ;
7907 int result;
7908 void *argp1 = 0 ;
7909 int res1 = 0 ;
7910 PyObject *swig_obj[1] ;
7911
7912 if (!args) SWIG_fail;
7913 swig_obj[0] = args;
7914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7915 if (!SWIG_IsOK(res1)) {
7916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7917 }
7918 arg1 = reinterpret_cast< wxRect * >(argp1);
7919 result = (int) ((arg1)->y);
7920 resultobj = SWIG_From_int(static_cast< int >(result));
7921 return resultobj;
7922 fail:
7923 return NULL;
7924 }
7925
7926
7927 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7928 PyObject *resultobj = 0;
7929 wxRect *arg1 = (wxRect *) 0 ;
7930 int arg2 ;
7931 void *argp1 = 0 ;
7932 int res1 = 0 ;
7933 int val2 ;
7934 int ecode2 = 0 ;
7935 PyObject *swig_obj[2] ;
7936
7937 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7939 if (!SWIG_IsOK(res1)) {
7940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7941 }
7942 arg1 = reinterpret_cast< wxRect * >(argp1);
7943 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7944 if (!SWIG_IsOK(ecode2)) {
7945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7946 }
7947 arg2 = static_cast< int >(val2);
7948 if (arg1) (arg1)->width = arg2;
7949
7950 resultobj = SWIG_Py_Void();
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7958 PyObject *resultobj = 0;
7959 wxRect *arg1 = (wxRect *) 0 ;
7960 int result;
7961 void *argp1 = 0 ;
7962 int res1 = 0 ;
7963 PyObject *swig_obj[1] ;
7964
7965 if (!args) SWIG_fail;
7966 swig_obj[0] = args;
7967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7968 if (!SWIG_IsOK(res1)) {
7969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7970 }
7971 arg1 = reinterpret_cast< wxRect * >(argp1);
7972 result = (int) ((arg1)->width);
7973 resultobj = SWIG_From_int(static_cast< int >(result));
7974 return resultobj;
7975 fail:
7976 return NULL;
7977 }
7978
7979
7980 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7981 PyObject *resultobj = 0;
7982 wxRect *arg1 = (wxRect *) 0 ;
7983 int arg2 ;
7984 void *argp1 = 0 ;
7985 int res1 = 0 ;
7986 int val2 ;
7987 int ecode2 = 0 ;
7988 PyObject *swig_obj[2] ;
7989
7990 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7994 }
7995 arg1 = reinterpret_cast< wxRect * >(argp1);
7996 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7997 if (!SWIG_IsOK(ecode2)) {
7998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7999 }
8000 arg2 = static_cast< int >(val2);
8001 if (arg1) (arg1)->height = arg2;
8002
8003 resultobj = SWIG_Py_Void();
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8011 PyObject *resultobj = 0;
8012 wxRect *arg1 = (wxRect *) 0 ;
8013 int result;
8014 void *argp1 = 0 ;
8015 int res1 = 0 ;
8016 PyObject *swig_obj[1] ;
8017
8018 if (!args) SWIG_fail;
8019 swig_obj[0] = args;
8020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8021 if (!SWIG_IsOK(res1)) {
8022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8023 }
8024 arg1 = reinterpret_cast< wxRect * >(argp1);
8025 result = (int) ((arg1)->height);
8026 resultobj = SWIG_From_int(static_cast< int >(result));
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxRect *arg1 = (wxRect *) 0 ;
8036 int arg2 = (int) 0 ;
8037 int arg3 = (int) 0 ;
8038 int arg4 = (int) 0 ;
8039 int arg5 = (int) 0 ;
8040 void *argp1 = 0 ;
8041 int res1 = 0 ;
8042 int val2 ;
8043 int ecode2 = 0 ;
8044 int val3 ;
8045 int ecode3 = 0 ;
8046 int val4 ;
8047 int ecode4 = 0 ;
8048 int val5 ;
8049 int ecode5 = 0 ;
8050 PyObject * obj0 = 0 ;
8051 PyObject * obj1 = 0 ;
8052 PyObject * obj2 = 0 ;
8053 PyObject * obj3 = 0 ;
8054 PyObject * obj4 = 0 ;
8055 char * kwnames[] = {
8056 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8057 };
8058
8059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8061 if (!SWIG_IsOK(res1)) {
8062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8063 }
8064 arg1 = reinterpret_cast< wxRect * >(argp1);
8065 if (obj1) {
8066 ecode2 = SWIG_AsVal_int(obj1, &val2);
8067 if (!SWIG_IsOK(ecode2)) {
8068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8069 }
8070 arg2 = static_cast< int >(val2);
8071 }
8072 if (obj2) {
8073 ecode3 = SWIG_AsVal_int(obj2, &val3);
8074 if (!SWIG_IsOK(ecode3)) {
8075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8076 }
8077 arg3 = static_cast< int >(val3);
8078 }
8079 if (obj3) {
8080 ecode4 = SWIG_AsVal_int(obj3, &val4);
8081 if (!SWIG_IsOK(ecode4)) {
8082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8083 }
8084 arg4 = static_cast< int >(val4);
8085 }
8086 if (obj4) {
8087 ecode5 = SWIG_AsVal_int(obj4, &val5);
8088 if (!SWIG_IsOK(ecode5)) {
8089 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8090 }
8091 arg5 = static_cast< int >(val5);
8092 }
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8096 wxPyEndAllowThreads(__tstate);
8097 if (PyErr_Occurred()) SWIG_fail;
8098 }
8099 resultobj = SWIG_Py_Void();
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *resultobj = 0;
8108 wxRect *arg1 = (wxRect *) 0 ;
8109 PyObject *result = 0 ;
8110 void *argp1 = 0 ;
8111 int res1 = 0 ;
8112 PyObject *swig_obj[1] ;
8113
8114 if (!args) SWIG_fail;
8115 swig_obj[0] = args;
8116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8117 if (!SWIG_IsOK(res1)) {
8118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8119 }
8120 arg1 = reinterpret_cast< wxRect * >(argp1);
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 result = (PyObject *)wxRect_Get(arg1);
8124 wxPyEndAllowThreads(__tstate);
8125 if (PyErr_Occurred()) SWIG_fail;
8126 }
8127 resultobj = result;
8128 return resultobj;
8129 fail:
8130 return NULL;
8131 }
8132
8133
8134 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8135 PyObject *obj;
8136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8137 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8138 return SWIG_Py_Void();
8139 }
8140
8141 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8142 return SWIG_Python_InitShadowInstance(args);
8143 }
8144
8145 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 wxRect *arg2 = (wxRect *) 0 ;
8149 PyObject *result = 0 ;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 void *argp2 = 0 ;
8153 int res2 = 0 ;
8154 PyObject * obj0 = 0 ;
8155 PyObject * obj1 = 0 ;
8156 char * kwnames[] = {
8157 (char *) "r1",(char *) "r2", NULL
8158 };
8159
8160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8162 if (!SWIG_IsOK(res1)) {
8163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8164 }
8165 arg1 = reinterpret_cast< wxRect * >(argp1);
8166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8167 if (!SWIG_IsOK(res2)) {
8168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8169 }
8170 arg2 = reinterpret_cast< wxRect * >(argp2);
8171 {
8172 if (!wxPyCheckForApp()) SWIG_fail;
8173 PyThreadState* __tstate = wxPyBeginAllowThreads();
8174 result = (PyObject *)wxIntersectRect(arg1,arg2);
8175 wxPyEndAllowThreads(__tstate);
8176 if (PyErr_Occurred()) SWIG_fail;
8177 }
8178 resultobj = result;
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 double arg1 = (double) 0.0 ;
8188 double arg2 = (double) 0.0 ;
8189 wxPoint2D *result = 0 ;
8190 double val1 ;
8191 int ecode1 = 0 ;
8192 double val2 ;
8193 int ecode2 = 0 ;
8194 PyObject * obj0 = 0 ;
8195 PyObject * obj1 = 0 ;
8196 char * kwnames[] = {
8197 (char *) "x",(char *) "y", NULL
8198 };
8199
8200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8201 if (obj0) {
8202 ecode1 = SWIG_AsVal_double(obj0, &val1);
8203 if (!SWIG_IsOK(ecode1)) {
8204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8205 }
8206 arg1 = static_cast< double >(val1);
8207 }
8208 if (obj1) {
8209 ecode2 = SWIG_AsVal_double(obj1, &val2);
8210 if (!SWIG_IsOK(ecode2)) {
8211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8212 }
8213 arg2 = static_cast< double >(val2);
8214 }
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8229 PyObject *resultobj = 0;
8230 wxPoint2D *arg1 = 0 ;
8231 wxPoint2D *result = 0 ;
8232 wxPoint2D temp1 ;
8233 PyObject * obj0 = 0 ;
8234 char * kwnames[] = {
8235 (char *) "pt", NULL
8236 };
8237
8238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8239 {
8240 arg1 = &temp1;
8241 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8242 }
8243 {
8244 PyThreadState* __tstate = wxPyBeginAllowThreads();
8245 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8246 wxPyEndAllowThreads(__tstate);
8247 if (PyErr_Occurred()) SWIG_fail;
8248 }
8249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8250 return resultobj;
8251 fail:
8252 return NULL;
8253 }
8254
8255
8256 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8257 PyObject *resultobj = 0;
8258 wxPoint *arg1 = 0 ;
8259 wxPoint2D *result = 0 ;
8260 wxPoint temp1 ;
8261 PyObject * obj0 = 0 ;
8262 char * kwnames[] = {
8263 (char *) "pt", NULL
8264 };
8265
8266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8267 {
8268 arg1 = &temp1;
8269 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8270 }
8271 {
8272 PyThreadState* __tstate = wxPyBeginAllowThreads();
8273 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8274 wxPyEndAllowThreads(__tstate);
8275 if (PyErr_Occurred()) SWIG_fail;
8276 }
8277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8278 return resultobj;
8279 fail:
8280 return NULL;
8281 }
8282
8283
8284 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8285 PyObject *resultobj = 0;
8286 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8287 int *arg2 = (int *) 0 ;
8288 int *arg3 = (int *) 0 ;
8289 void *argp1 = 0 ;
8290 int res1 = 0 ;
8291 int temp2 ;
8292 int res2 = SWIG_TMPOBJ ;
8293 int temp3 ;
8294 int res3 = SWIG_TMPOBJ ;
8295 PyObject *swig_obj[1] ;
8296
8297 arg2 = &temp2;
8298 arg3 = &temp3;
8299 if (!args) SWIG_fail;
8300 swig_obj[0] = args;
8301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8302 if (!SWIG_IsOK(res1)) {
8303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8304 }
8305 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8309 wxPyEndAllowThreads(__tstate);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 resultobj = SWIG_Py_Void();
8313 if (SWIG_IsTmpObj(res2)) {
8314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8315 } else {
8316 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8318 }
8319 if (SWIG_IsTmpObj(res3)) {
8320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8321 } else {
8322 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8324 }
8325 return resultobj;
8326 fail:
8327 return NULL;
8328 }
8329
8330
8331 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8332 PyObject *resultobj = 0;
8333 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8334 int *arg2 = (int *) 0 ;
8335 int *arg3 = (int *) 0 ;
8336 void *argp1 = 0 ;
8337 int res1 = 0 ;
8338 int temp2 ;
8339 int res2 = SWIG_TMPOBJ ;
8340 int temp3 ;
8341 int res3 = SWIG_TMPOBJ ;
8342 PyObject *swig_obj[1] ;
8343
8344 arg2 = &temp2;
8345 arg3 = &temp3;
8346 if (!args) SWIG_fail;
8347 swig_obj[0] = args;
8348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8349 if (!SWIG_IsOK(res1)) {
8350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8351 }
8352 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8356 wxPyEndAllowThreads(__tstate);
8357 if (PyErr_Occurred()) SWIG_fail;
8358 }
8359 resultobj = SWIG_Py_Void();
8360 if (SWIG_IsTmpObj(res2)) {
8361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8362 } else {
8363 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8365 }
8366 if (SWIG_IsTmpObj(res3)) {
8367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8368 } else {
8369 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8371 }
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8379 PyObject *resultobj = 0;
8380 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8381 double result;
8382 void *argp1 = 0 ;
8383 int res1 = 0 ;
8384 PyObject *swig_obj[1] ;
8385
8386 if (!args) SWIG_fail;
8387 swig_obj[0] = args;
8388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8389 if (!SWIG_IsOK(res1)) {
8390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8391 }
8392 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 resultobj = SWIG_From_double(static_cast< double >(result));
8400 return resultobj;
8401 fail:
8402 return NULL;
8403 }
8404
8405
8406 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8407 PyObject *resultobj = 0;
8408 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8409 double result;
8410 void *argp1 = 0 ;
8411 int res1 = 0 ;
8412 PyObject *swig_obj[1] ;
8413
8414 if (!args) SWIG_fail;
8415 swig_obj[0] = args;
8416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8419 }
8420 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 resultobj = SWIG_From_double(static_cast< double >(result));
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj = 0;
8436 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8437 double arg2 ;
8438 void *argp1 = 0 ;
8439 int res1 = 0 ;
8440 double val2 ;
8441 int ecode2 = 0 ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char * kwnames[] = {
8445 (char *) "self",(char *) "length", NULL
8446 };
8447
8448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8452 }
8453 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8454 ecode2 = SWIG_AsVal_double(obj1, &val2);
8455 if (!SWIG_IsOK(ecode2)) {
8456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8457 }
8458 arg2 = static_cast< double >(val2);
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 (arg1)->SetVectorLength(arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_Py_Void();
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 double arg2 ;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 double val2 ;
8479 int ecode2 = 0 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "degrees", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 ecode2 = SWIG_AsVal_double(obj1, &val2);
8493 if (!SWIG_IsOK(ecode2)) {
8494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8495 }
8496 arg2 = static_cast< double >(val2);
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 (arg1)->SetVectorAngle(arg2);
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_Py_Void();
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj = 0;
8512 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8513 wxPoint2D *arg2 = 0 ;
8514 double result;
8515 void *argp1 = 0 ;
8516 int res1 = 0 ;
8517 wxPoint2D temp2 ;
8518 PyObject * obj0 = 0 ;
8519 PyObject * obj1 = 0 ;
8520 char * kwnames[] = {
8521 (char *) "self",(char *) "pt", NULL
8522 };
8523
8524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8526 if (!SWIG_IsOK(res1)) {
8527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8528 }
8529 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8530 {
8531 arg2 = &temp2;
8532 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8533 }
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 resultobj = SWIG_From_double(static_cast< double >(result));
8541 return resultobj;
8542 fail:
8543 return NULL;
8544 }
8545
8546
8547 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8548 PyObject *resultobj = 0;
8549 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8550 wxPoint2D *arg2 = 0 ;
8551 double result;
8552 void *argp1 = 0 ;
8553 int res1 = 0 ;
8554 wxPoint2D temp2 ;
8555 PyObject * obj0 = 0 ;
8556 PyObject * obj1 = 0 ;
8557 char * kwnames[] = {
8558 (char *) "self",(char *) "pt", NULL
8559 };
8560
8561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8565 }
8566 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8567 {
8568 arg2 = &temp2;
8569 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8570 }
8571 {
8572 PyThreadState* __tstate = wxPyBeginAllowThreads();
8573 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8574 wxPyEndAllowThreads(__tstate);
8575 if (PyErr_Occurred()) SWIG_fail;
8576 }
8577 resultobj = SWIG_From_double(static_cast< double >(result));
8578 return resultobj;
8579 fail:
8580 return NULL;
8581 }
8582
8583
8584 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8585 PyObject *resultobj = 0;
8586 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8587 wxPoint2D *arg2 = 0 ;
8588 double result;
8589 void *argp1 = 0 ;
8590 int res1 = 0 ;
8591 wxPoint2D temp2 ;
8592 PyObject * obj0 = 0 ;
8593 PyObject * obj1 = 0 ;
8594 char * kwnames[] = {
8595 (char *) "self",(char *) "vec", NULL
8596 };
8597
8598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8600 if (!SWIG_IsOK(res1)) {
8601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8602 }
8603 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8604 {
8605 arg2 = &temp2;
8606 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8607 }
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8611 wxPyEndAllowThreads(__tstate);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 resultobj = SWIG_From_double(static_cast< double >(result));
8615 return resultobj;
8616 fail:
8617 return NULL;
8618 }
8619
8620
8621 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8622 PyObject *resultobj = 0;
8623 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8624 wxPoint2D *arg2 = 0 ;
8625 double result;
8626 void *argp1 = 0 ;
8627 int res1 = 0 ;
8628 wxPoint2D temp2 ;
8629 PyObject * obj0 = 0 ;
8630 PyObject * obj1 = 0 ;
8631 char * kwnames[] = {
8632 (char *) "self",(char *) "vec", NULL
8633 };
8634
8635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8637 if (!SWIG_IsOK(res1)) {
8638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8639 }
8640 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8641 {
8642 arg2 = &temp2;
8643 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8644 }
8645 {
8646 PyThreadState* __tstate = wxPyBeginAllowThreads();
8647 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8648 wxPyEndAllowThreads(__tstate);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 resultobj = SWIG_From_double(static_cast< double >(result));
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8659 PyObject *resultobj = 0;
8660 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8661 wxPoint2D result;
8662 void *argp1 = 0 ;
8663 int res1 = 0 ;
8664 PyObject *swig_obj[1] ;
8665
8666 if (!args) SWIG_fail;
8667 swig_obj[0] = args;
8668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8669 if (!SWIG_IsOK(res1)) {
8670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8671 }
8672 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 result = (arg1)->operator -();
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8680 return resultobj;
8681 fail:
8682 return NULL;
8683 }
8684
8685
8686 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8687 PyObject *resultobj = 0;
8688 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8689 wxPoint2D *arg2 = 0 ;
8690 wxPoint2D *result = 0 ;
8691 void *argp1 = 0 ;
8692 int res1 = 0 ;
8693 wxPoint2D temp2 ;
8694 PyObject * obj0 = 0 ;
8695 PyObject * obj1 = 0 ;
8696 char * kwnames[] = {
8697 (char *) "self",(char *) "pt", NULL
8698 };
8699
8700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8702 if (!SWIG_IsOK(res1)) {
8703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8704 }
8705 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8706 {
8707 arg2 = &temp2;
8708 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8709 }
8710 {
8711 PyThreadState* __tstate = wxPyBeginAllowThreads();
8712 {
8713 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8714 result = (wxPoint2D *) &_result_ref;
8715 }
8716 wxPyEndAllowThreads(__tstate);
8717 if (PyErr_Occurred()) SWIG_fail;
8718 }
8719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8720 return resultobj;
8721 fail:
8722 return NULL;
8723 }
8724
8725
8726 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8727 PyObject *resultobj = 0;
8728 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8729 wxPoint2D *arg2 = 0 ;
8730 wxPoint2D *result = 0 ;
8731 void *argp1 = 0 ;
8732 int res1 = 0 ;
8733 wxPoint2D temp2 ;
8734 PyObject * obj0 = 0 ;
8735 PyObject * obj1 = 0 ;
8736 char * kwnames[] = {
8737 (char *) "self",(char *) "pt", NULL
8738 };
8739
8740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8742 if (!SWIG_IsOK(res1)) {
8743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8744 }
8745 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8746 {
8747 arg2 = &temp2;
8748 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8749 }
8750 {
8751 PyThreadState* __tstate = wxPyBeginAllowThreads();
8752 {
8753 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8754 result = (wxPoint2D *) &_result_ref;
8755 }
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 wxPoint2D *arg2 = 0 ;
8770 wxPoint2D *result = 0 ;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 wxPoint2D temp2 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "pt", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 {
8787 arg2 = &temp2;
8788 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8789 }
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 {
8793 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8794 result = (wxPoint2D *) &_result_ref;
8795 }
8796 wxPyEndAllowThreads(__tstate);
8797 if (PyErr_Occurred()) SWIG_fail;
8798 }
8799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8800 return resultobj;
8801 fail:
8802 return NULL;
8803 }
8804
8805
8806 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8807 PyObject *resultobj = 0;
8808 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8809 wxPoint2D *arg2 = 0 ;
8810 wxPoint2D *result = 0 ;
8811 void *argp1 = 0 ;
8812 int res1 = 0 ;
8813 wxPoint2D temp2 ;
8814 PyObject * obj0 = 0 ;
8815 PyObject * obj1 = 0 ;
8816 char * kwnames[] = {
8817 (char *) "self",(char *) "pt", NULL
8818 };
8819
8820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8822 if (!SWIG_IsOK(res1)) {
8823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8824 }
8825 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8826 {
8827 arg2 = &temp2;
8828 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8829 }
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 {
8833 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8834 result = (wxPoint2D *) &_result_ref;
8835 }
8836 wxPyEndAllowThreads(__tstate);
8837 if (PyErr_Occurred()) SWIG_fail;
8838 }
8839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8840 return resultobj;
8841 fail:
8842 return NULL;
8843 }
8844
8845
8846 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8847 PyObject *resultobj = 0;
8848 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8849 PyObject *arg2 = (PyObject *) 0 ;
8850 bool result;
8851 void *argp1 = 0 ;
8852 int res1 = 0 ;
8853 PyObject * obj0 = 0 ;
8854 PyObject * obj1 = 0 ;
8855 char * kwnames[] = {
8856 (char *) "self",(char *) "other", NULL
8857 };
8858
8859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8861 if (!SWIG_IsOK(res1)) {
8862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8863 }
8864 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8865 arg2 = obj1;
8866 {
8867 result = (bool)wxPoint2D___eq__(arg1,arg2);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 {
8871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8872 }
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8880 PyObject *resultobj = 0;
8881 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8882 PyObject *arg2 = (PyObject *) 0 ;
8883 bool result;
8884 void *argp1 = 0 ;
8885 int res1 = 0 ;
8886 PyObject * obj0 = 0 ;
8887 PyObject * obj1 = 0 ;
8888 char * kwnames[] = {
8889 (char *) "self",(char *) "other", NULL
8890 };
8891
8892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 arg2 = obj1;
8899 {
8900 result = (bool)wxPoint2D___ne__(arg1,arg2);
8901 if (PyErr_Occurred()) SWIG_fail;
8902 }
8903 {
8904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8905 }
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8913 PyObject *resultobj = 0;
8914 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8915 double arg2 ;
8916 void *argp1 = 0 ;
8917 int res1 = 0 ;
8918 double val2 ;
8919 int ecode2 = 0 ;
8920 PyObject *swig_obj[2] ;
8921
8922 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8924 if (!SWIG_IsOK(res1)) {
8925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8926 }
8927 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8928 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8929 if (!SWIG_IsOK(ecode2)) {
8930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8931 }
8932 arg2 = static_cast< double >(val2);
8933 if (arg1) (arg1)->m_x = arg2;
8934
8935 resultobj = SWIG_Py_Void();
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943 PyObject *resultobj = 0;
8944 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8945 double result;
8946 void *argp1 = 0 ;
8947 int res1 = 0 ;
8948 PyObject *swig_obj[1] ;
8949
8950 if (!args) SWIG_fail;
8951 swig_obj[0] = args;
8952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8953 if (!SWIG_IsOK(res1)) {
8954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8955 }
8956 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8957 result = (double) ((arg1)->m_x);
8958 resultobj = SWIG_From_double(static_cast< double >(result));
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8966 PyObject *resultobj = 0;
8967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8968 double arg2 ;
8969 void *argp1 = 0 ;
8970 int res1 = 0 ;
8971 double val2 ;
8972 int ecode2 = 0 ;
8973 PyObject *swig_obj[2] ;
8974
8975 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8977 if (!SWIG_IsOK(res1)) {
8978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8979 }
8980 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8981 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8982 if (!SWIG_IsOK(ecode2)) {
8983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8984 }
8985 arg2 = static_cast< double >(val2);
8986 if (arg1) (arg1)->m_y = arg2;
8987
8988 resultobj = SWIG_Py_Void();
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8998 double result;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 PyObject *swig_obj[1] ;
9002
9003 if (!args) SWIG_fail;
9004 swig_obj[0] = args;
9005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9006 if (!SWIG_IsOK(res1)) {
9007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9008 }
9009 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9010 result = (double) ((arg1)->m_y);
9011 resultobj = SWIG_From_double(static_cast< double >(result));
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj = 0;
9020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9021 double arg2 = (double) 0 ;
9022 double arg3 = (double) 0 ;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 double val2 ;
9026 int ecode2 = 0 ;
9027 double val3 ;
9028 int ecode3 = 0 ;
9029 PyObject * obj0 = 0 ;
9030 PyObject * obj1 = 0 ;
9031 PyObject * obj2 = 0 ;
9032 char * kwnames[] = {
9033 (char *) "self",(char *) "x",(char *) "y", NULL
9034 };
9035
9036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9038 if (!SWIG_IsOK(res1)) {
9039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9040 }
9041 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9042 if (obj1) {
9043 ecode2 = SWIG_AsVal_double(obj1, &val2);
9044 if (!SWIG_IsOK(ecode2)) {
9045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9046 }
9047 arg2 = static_cast< double >(val2);
9048 }
9049 if (obj2) {
9050 ecode3 = SWIG_AsVal_double(obj2, &val3);
9051 if (!SWIG_IsOK(ecode3)) {
9052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9053 }
9054 arg3 = static_cast< double >(val3);
9055 }
9056 {
9057 PyThreadState* __tstate = wxPyBeginAllowThreads();
9058 wxPoint2D_Set(arg1,arg2,arg3);
9059 wxPyEndAllowThreads(__tstate);
9060 if (PyErr_Occurred()) SWIG_fail;
9061 }
9062 resultobj = SWIG_Py_Void();
9063 return resultobj;
9064 fail:
9065 return NULL;
9066 }
9067
9068
9069 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9070 PyObject *resultobj = 0;
9071 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9072 PyObject *result = 0 ;
9073 void *argp1 = 0 ;
9074 int res1 = 0 ;
9075 PyObject *swig_obj[1] ;
9076
9077 if (!args) SWIG_fail;
9078 swig_obj[0] = args;
9079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9080 if (!SWIG_IsOK(res1)) {
9081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9082 }
9083 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 result = (PyObject *)wxPoint2D_Get(arg1);
9087 wxPyEndAllowThreads(__tstate);
9088 if (PyErr_Occurred()) SWIG_fail;
9089 }
9090 resultobj = result;
9091 return resultobj;
9092 fail:
9093 return NULL;
9094 }
9095
9096
9097 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9098 PyObject *obj;
9099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9100 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9101 return SWIG_Py_Void();
9102 }
9103
9104 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105 return SWIG_Python_InitShadowInstance(args);
9106 }
9107
9108 SWIGINTERN int DefaultPosition_set(PyObject *) {
9109 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9110 return 1;
9111 }
9112
9113
9114 SWIGINTERN PyObject *DefaultPosition_get(void) {
9115 PyObject *pyobj = 0;
9116
9117 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9118 return pyobj;
9119 }
9120
9121
9122 SWIGINTERN int DefaultSize_set(PyObject *) {
9123 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9124 return 1;
9125 }
9126
9127
9128 SWIGINTERN PyObject *DefaultSize_get(void) {
9129 PyObject *pyobj = 0;
9130
9131 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9132 return pyobj;
9133 }
9134
9135
9136 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9137 PyObject *resultobj = 0;
9138 PyObject *arg1 = (PyObject *) 0 ;
9139 wxPyInputStream *result = 0 ;
9140 PyObject * obj0 = 0 ;
9141 char * kwnames[] = {
9142 (char *) "p", NULL
9143 };
9144
9145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9146 arg1 = obj0;
9147 {
9148 PyThreadState* __tstate = wxPyBeginAllowThreads();
9149 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9150 wxPyEndAllowThreads(__tstate);
9151 if (PyErr_Occurred()) SWIG_fail;
9152 }
9153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9161 PyObject *resultobj = 0;
9162 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9163 void *argp1 = 0 ;
9164 int res1 = 0 ;
9165 PyObject *swig_obj[1] ;
9166
9167 if (!args) SWIG_fail;
9168 swig_obj[0] = args;
9169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9170 if (!SWIG_IsOK(res1)) {
9171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9172 }
9173 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 delete arg1;
9177
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 resultobj = SWIG_Py_Void();
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9189 PyObject *resultobj = 0;
9190 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9191 void *argp1 = 0 ;
9192 int res1 = 0 ;
9193 PyObject *swig_obj[1] ;
9194
9195 if (!args) SWIG_fail;
9196 swig_obj[0] = args;
9197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9198 if (!SWIG_IsOK(res1)) {
9199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9200 }
9201 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9202 {
9203 PyThreadState* __tstate = wxPyBeginAllowThreads();
9204 (arg1)->close();
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_Py_Void();
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9218 void *argp1 = 0 ;
9219 int res1 = 0 ;
9220 PyObject *swig_obj[1] ;
9221
9222 if (!args) SWIG_fail;
9223 swig_obj[0] = args;
9224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9225 if (!SWIG_IsOK(res1)) {
9226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9227 }
9228 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 (arg1)->flush();
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = SWIG_Py_Void();
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 bool result;
9246 void *argp1 = 0 ;
9247 int res1 = 0 ;
9248 PyObject *swig_obj[1] ;
9249
9250 if (!args) SWIG_fail;
9251 swig_obj[0] = args;
9252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9253 if (!SWIG_IsOK(res1)) {
9254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9255 }
9256 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (bool)(arg1)->eof();
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 {
9264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9265 }
9266 return resultobj;
9267 fail:
9268 return NULL;
9269 }
9270
9271
9272 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9273 PyObject *resultobj = 0;
9274 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9275 int arg2 = (int) -1 ;
9276 PyObject *result = 0 ;
9277 void *argp1 = 0 ;
9278 int res1 = 0 ;
9279 int val2 ;
9280 int ecode2 = 0 ;
9281 PyObject * obj0 = 0 ;
9282 PyObject * obj1 = 0 ;
9283 char * kwnames[] = {
9284 (char *) "self",(char *) "size", NULL
9285 };
9286
9287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9289 if (!SWIG_IsOK(res1)) {
9290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9291 }
9292 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9293 if (obj1) {
9294 ecode2 = SWIG_AsVal_int(obj1, &val2);
9295 if (!SWIG_IsOK(ecode2)) {
9296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9297 }
9298 arg2 = static_cast< int >(val2);
9299 }
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (PyObject *)(arg1)->read(arg2);
9303 wxPyEndAllowThreads(__tstate);
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 resultobj = result;
9307 return resultobj;
9308 fail:
9309 return NULL;
9310 }
9311
9312
9313 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9314 PyObject *resultobj = 0;
9315 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9316 int arg2 = (int) -1 ;
9317 PyObject *result = 0 ;
9318 void *argp1 = 0 ;
9319 int res1 = 0 ;
9320 int val2 ;
9321 int ecode2 = 0 ;
9322 PyObject * obj0 = 0 ;
9323 PyObject * obj1 = 0 ;
9324 char * kwnames[] = {
9325 (char *) "self",(char *) "size", NULL
9326 };
9327
9328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9330 if (!SWIG_IsOK(res1)) {
9331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9332 }
9333 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9334 if (obj1) {
9335 ecode2 = SWIG_AsVal_int(obj1, &val2);
9336 if (!SWIG_IsOK(ecode2)) {
9337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9338 }
9339 arg2 = static_cast< int >(val2);
9340 }
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 result = (PyObject *)(arg1)->readline(arg2);
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 resultobj = result;
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9355 PyObject *resultobj = 0;
9356 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9357 int arg2 = (int) -1 ;
9358 PyObject *result = 0 ;
9359 void *argp1 = 0 ;
9360 int res1 = 0 ;
9361 int val2 ;
9362 int ecode2 = 0 ;
9363 PyObject * obj0 = 0 ;
9364 PyObject * obj1 = 0 ;
9365 char * kwnames[] = {
9366 (char *) "self",(char *) "sizehint", NULL
9367 };
9368
9369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9373 }
9374 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9375 if (obj1) {
9376 ecode2 = SWIG_AsVal_int(obj1, &val2);
9377 if (!SWIG_IsOK(ecode2)) {
9378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9379 }
9380 arg2 = static_cast< int >(val2);
9381 }
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (PyObject *)(arg1)->readlines(arg2);
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 resultobj = result;
9389 return resultobj;
9390 fail:
9391 return NULL;
9392 }
9393
9394
9395 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9396 PyObject *resultobj = 0;
9397 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9398 int arg2 ;
9399 int arg3 = (int) 0 ;
9400 void *argp1 = 0 ;
9401 int res1 = 0 ;
9402 int val2 ;
9403 int ecode2 = 0 ;
9404 int val3 ;
9405 int ecode3 = 0 ;
9406 PyObject * obj0 = 0 ;
9407 PyObject * obj1 = 0 ;
9408 PyObject * obj2 = 0 ;
9409 char * kwnames[] = {
9410 (char *) "self",(char *) "offset",(char *) "whence", NULL
9411 };
9412
9413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9415 if (!SWIG_IsOK(res1)) {
9416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9417 }
9418 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9419 ecode2 = SWIG_AsVal_int(obj1, &val2);
9420 if (!SWIG_IsOK(ecode2)) {
9421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9422 }
9423 arg2 = static_cast< int >(val2);
9424 if (obj2) {
9425 ecode3 = SWIG_AsVal_int(obj2, &val3);
9426 if (!SWIG_IsOK(ecode3)) {
9427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9428 }
9429 arg3 = static_cast< int >(val3);
9430 }
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 (arg1)->seek(arg2,arg3);
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_Py_Void();
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 int result;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 PyObject *swig_obj[1] ;
9451
9452 if (!args) SWIG_fail;
9453 swig_obj[0] = args;
9454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (int)(arg1)->tell();
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 resultobj = SWIG_From_int(static_cast< int >(result));
9466 return resultobj;
9467 fail:
9468 return NULL;
9469 }
9470
9471
9472 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9473 PyObject *resultobj = 0;
9474 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9475 char result;
9476 void *argp1 = 0 ;
9477 int res1 = 0 ;
9478 PyObject *swig_obj[1] ;
9479
9480 if (!args) SWIG_fail;
9481 swig_obj[0] = args;
9482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9483 if (!SWIG_IsOK(res1)) {
9484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9485 }
9486 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9487 {
9488 PyThreadState* __tstate = wxPyBeginAllowThreads();
9489 result = (char)(arg1)->Peek();
9490 wxPyEndAllowThreads(__tstate);
9491 if (PyErr_Occurred()) SWIG_fail;
9492 }
9493 resultobj = SWIG_From_char(static_cast< char >(result));
9494 return resultobj;
9495 fail:
9496 return NULL;
9497 }
9498
9499
9500 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9501 PyObject *resultobj = 0;
9502 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9503 char result;
9504 void *argp1 = 0 ;
9505 int res1 = 0 ;
9506 PyObject *swig_obj[1] ;
9507
9508 if (!args) SWIG_fail;
9509 swig_obj[0] = args;
9510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9511 if (!SWIG_IsOK(res1)) {
9512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9513 }
9514 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (char)(arg1)->GetC();
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 resultobj = SWIG_From_char(static_cast< char >(result));
9522 return resultobj;
9523 fail:
9524 return NULL;
9525 }
9526
9527
9528 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9529 PyObject *resultobj = 0;
9530 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9531 size_t result;
9532 void *argp1 = 0 ;
9533 int res1 = 0 ;
9534 PyObject *swig_obj[1] ;
9535
9536 if (!args) SWIG_fail;
9537 swig_obj[0] = args;
9538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9541 }
9542 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9543 {
9544 PyThreadState* __tstate = wxPyBeginAllowThreads();
9545 result = (size_t)(arg1)->LastRead();
9546 wxPyEndAllowThreads(__tstate);
9547 if (PyErr_Occurred()) SWIG_fail;
9548 }
9549 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9557 PyObject *resultobj = 0;
9558 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9559 bool result;
9560 void *argp1 = 0 ;
9561 int res1 = 0 ;
9562 PyObject *swig_obj[1] ;
9563
9564 if (!args) SWIG_fail;
9565 swig_obj[0] = args;
9566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9567 if (!SWIG_IsOK(res1)) {
9568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9569 }
9570 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 result = (bool)(arg1)->CanRead();
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 {
9578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9579 }
9580 return resultobj;
9581 fail:
9582 return NULL;
9583 }
9584
9585
9586 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9587 PyObject *resultobj = 0;
9588 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9589 bool result;
9590 void *argp1 = 0 ;
9591 int res1 = 0 ;
9592 PyObject *swig_obj[1] ;
9593
9594 if (!args) SWIG_fail;
9595 swig_obj[0] = args;
9596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9597 if (!SWIG_IsOK(res1)) {
9598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9599 }
9600 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9601 {
9602 PyThreadState* __tstate = wxPyBeginAllowThreads();
9603 result = (bool)(arg1)->Eof();
9604 wxPyEndAllowThreads(__tstate);
9605 if (PyErr_Occurred()) SWIG_fail;
9606 }
9607 {
9608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9609 }
9610 return resultobj;
9611 fail:
9612 return NULL;
9613 }
9614
9615
9616 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj = 0;
9618 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9619 char arg2 ;
9620 bool result;
9621 void *argp1 = 0 ;
9622 int res1 = 0 ;
9623 char val2 ;
9624 int ecode2 = 0 ;
9625 PyObject * obj0 = 0 ;
9626 PyObject * obj1 = 0 ;
9627 char * kwnames[] = {
9628 (char *) "self",(char *) "c", NULL
9629 };
9630
9631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9633 if (!SWIG_IsOK(res1)) {
9634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9635 }
9636 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9637 ecode2 = SWIG_AsVal_char(obj1, &val2);
9638 if (!SWIG_IsOK(ecode2)) {
9639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9640 }
9641 arg2 = static_cast< char >(val2);
9642 {
9643 PyThreadState* __tstate = wxPyBeginAllowThreads();
9644 result = (bool)(arg1)->Ungetch(arg2);
9645 wxPyEndAllowThreads(__tstate);
9646 if (PyErr_Occurred()) SWIG_fail;
9647 }
9648 {
9649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9650 }
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj = 0;
9659 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9660 long arg2 ;
9661 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9662 long result;
9663 void *argp1 = 0 ;
9664 int res1 = 0 ;
9665 long val2 ;
9666 int ecode2 = 0 ;
9667 int val3 ;
9668 int ecode3 = 0 ;
9669 PyObject * obj0 = 0 ;
9670 PyObject * obj1 = 0 ;
9671 PyObject * obj2 = 0 ;
9672 char * kwnames[] = {
9673 (char *) "self",(char *) "pos",(char *) "mode", NULL
9674 };
9675
9676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9678 if (!SWIG_IsOK(res1)) {
9679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9680 }
9681 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9682 ecode2 = SWIG_AsVal_long(obj1, &val2);
9683 if (!SWIG_IsOK(ecode2)) {
9684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9685 }
9686 arg2 = static_cast< long >(val2);
9687 if (obj2) {
9688 ecode3 = SWIG_AsVal_int(obj2, &val3);
9689 if (!SWIG_IsOK(ecode3)) {
9690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9691 }
9692 arg3 = static_cast< wxSeekMode >(val3);
9693 }
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 result = (long)(arg1)->SeekI(arg2,arg3);
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 resultobj = SWIG_From_long(static_cast< long >(result));
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9708 PyObject *resultobj = 0;
9709 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9710 long result;
9711 void *argp1 = 0 ;
9712 int res1 = 0 ;
9713 PyObject *swig_obj[1] ;
9714
9715 if (!args) SWIG_fail;
9716 swig_obj[0] = args;
9717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9718 if (!SWIG_IsOK(res1)) {
9719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9720 }
9721 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 result = (long)(arg1)->TellI();
9725 wxPyEndAllowThreads(__tstate);
9726 if (PyErr_Occurred()) SWIG_fail;
9727 }
9728 resultobj = SWIG_From_long(static_cast< long >(result));
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9736 PyObject *obj;
9737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9738 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9739 return SWIG_Py_Void();
9740 }
9741
9742 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9743 return SWIG_Python_InitShadowInstance(args);
9744 }
9745
9746 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9747 PyObject *resultobj = 0;
9748 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9749 PyObject *arg2 = (PyObject *) 0 ;
9750 void *argp1 = 0 ;
9751 int res1 = 0 ;
9752 PyObject * obj0 = 0 ;
9753 PyObject * obj1 = 0 ;
9754 char * kwnames[] = {
9755 (char *) "self",(char *) "obj", NULL
9756 };
9757
9758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9762 }
9763 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9764 arg2 = obj1;
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 wxOutputStream_write(arg1,arg2);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_Py_Void();
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9779 PyObject *resultobj = 0;
9780 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9781 size_t result;
9782 void *argp1 = 0 ;
9783 int res1 = 0 ;
9784 PyObject *swig_obj[1] ;
9785
9786 if (!args) SWIG_fail;
9787 swig_obj[0] = args;
9788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9789 if (!SWIG_IsOK(res1)) {
9790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9791 }
9792 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9793 {
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9796 wxPyEndAllowThreads(__tstate);
9797 if (PyErr_Occurred()) SWIG_fail;
9798 }
9799 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *obj;
9808 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9809 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9810 return SWIG_Py_Void();
9811 }
9812
9813 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9814 PyObject *resultobj = 0;
9815 wxInputStream *arg1 = (wxInputStream *) 0 ;
9816 wxString *arg2 = 0 ;
9817 wxString *arg3 = 0 ;
9818 wxString *arg4 = 0 ;
9819 wxDateTime arg5 ;
9820 wxFSFile *result = 0 ;
9821 wxPyInputStream *temp1 ;
9822 bool temp2 = false ;
9823 bool temp3 = false ;
9824 bool temp4 = false ;
9825 void *argp5 ;
9826 int res5 = 0 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 PyObject * obj2 = 0 ;
9830 PyObject * obj3 = 0 ;
9831 PyObject * obj4 = 0 ;
9832 char * kwnames[] = {
9833 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9834 };
9835
9836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9837 {
9838 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9839 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9840 } else {
9841 PyErr_Clear(); // clear the failure of the wxPyConvert above
9842 arg1 = wxPyCBInputStream_create(obj0, true);
9843 if (arg1 == NULL) {
9844 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9845 SWIG_fail;
9846 }
9847 }
9848 }
9849 {
9850 arg2 = wxString_in_helper(obj1);
9851 if (arg2 == NULL) SWIG_fail;
9852 temp2 = true;
9853 }
9854 {
9855 arg3 = wxString_in_helper(obj2);
9856 if (arg3 == NULL) SWIG_fail;
9857 temp3 = true;
9858 }
9859 {
9860 arg4 = wxString_in_helper(obj3);
9861 if (arg4 == NULL) SWIG_fail;
9862 temp4 = true;
9863 }
9864 {
9865 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9866 if (!SWIG_IsOK(res5)) {
9867 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9868 }
9869 if (!argp5) {
9870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9871 } else {
9872 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9873 arg5 = *temp;
9874 if (SWIG_IsNewObj(res5)) delete temp;
9875 }
9876 }
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9880 wxPyEndAllowThreads(__tstate);
9881 if (PyErr_Occurred()) SWIG_fail;
9882 }
9883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9884 {
9885 if (temp2)
9886 delete arg2;
9887 }
9888 {
9889 if (temp3)
9890 delete arg3;
9891 }
9892 {
9893 if (temp4)
9894 delete arg4;
9895 }
9896 return resultobj;
9897 fail:
9898 {
9899 if (temp2)
9900 delete arg2;
9901 }
9902 {
9903 if (temp3)
9904 delete arg3;
9905 }
9906 {
9907 if (temp4)
9908 delete arg4;
9909 }
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9915 PyObject *resultobj = 0;
9916 wxFSFile *arg1 = (wxFSFile *) 0 ;
9917 void *argp1 = 0 ;
9918 int res1 = 0 ;
9919 PyObject *swig_obj[1] ;
9920
9921 if (!args) SWIG_fail;
9922 swig_obj[0] = args;
9923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9924 if (!SWIG_IsOK(res1)) {
9925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9926 }
9927 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 delete arg1;
9931
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 resultobj = SWIG_Py_Void();
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9943 PyObject *resultobj = 0;
9944 wxFSFile *arg1 = (wxFSFile *) 0 ;
9945 wxInputStream *result = 0 ;
9946 void *argp1 = 0 ;
9947 int res1 = 0 ;
9948 PyObject *swig_obj[1] ;
9949
9950 if (!args) SWIG_fail;
9951 swig_obj[0] = args;
9952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9953 if (!SWIG_IsOK(res1)) {
9954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9955 }
9956 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9957 {
9958 PyThreadState* __tstate = wxPyBeginAllowThreads();
9959 result = (wxInputStream *)(arg1)->GetStream();
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 wxPyInputStream * _ptr = NULL;
9965
9966 if (result) {
9967 _ptr = new wxPyInputStream(result);
9968 }
9969 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9970 }
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9978 PyObject *resultobj = 0;
9979 wxFSFile *arg1 = (wxFSFile *) 0 ;
9980 void *argp1 = 0 ;
9981 int res1 = 0 ;
9982 PyObject *swig_obj[1] ;
9983
9984 if (!args) SWIG_fail;
9985 swig_obj[0] = args;
9986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9987 if (!SWIG_IsOK(res1)) {
9988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9989 }
9990 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 (arg1)->DetachStream();
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_Py_Void();
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *resultobj = 0;
10006 wxFSFile *arg1 = (wxFSFile *) 0 ;
10007 wxString *result = 0 ;
10008 void *argp1 = 0 ;
10009 int res1 = 0 ;
10010 PyObject *swig_obj[1] ;
10011
10012 if (!args) SWIG_fail;
10013 swig_obj[0] = args;
10014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10015 if (!SWIG_IsOK(res1)) {
10016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10017 }
10018 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10019 {
10020 PyThreadState* __tstate = wxPyBeginAllowThreads();
10021 {
10022 wxString const &_result_ref = (arg1)->GetMimeType();
10023 result = (wxString *) &_result_ref;
10024 }
10025 wxPyEndAllowThreads(__tstate);
10026 if (PyErr_Occurred()) SWIG_fail;
10027 }
10028 {
10029 #if wxUSE_UNICODE
10030 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10031 #else
10032 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10033 #endif
10034 }
10035 return resultobj;
10036 fail:
10037 return NULL;
10038 }
10039
10040
10041 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10042 PyObject *resultobj = 0;
10043 wxFSFile *arg1 = (wxFSFile *) 0 ;
10044 wxString *result = 0 ;
10045 void *argp1 = 0 ;
10046 int res1 = 0 ;
10047 PyObject *swig_obj[1] ;
10048
10049 if (!args) SWIG_fail;
10050 swig_obj[0] = args;
10051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10052 if (!SWIG_IsOK(res1)) {
10053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10054 }
10055 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 {
10059 wxString const &_result_ref = (arg1)->GetLocation();
10060 result = (wxString *) &_result_ref;
10061 }
10062 wxPyEndAllowThreads(__tstate);
10063 if (PyErr_Occurred()) SWIG_fail;
10064 }
10065 {
10066 #if wxUSE_UNICODE
10067 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10068 #else
10069 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10070 #endif
10071 }
10072 return resultobj;
10073 fail:
10074 return NULL;
10075 }
10076
10077
10078 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10079 PyObject *resultobj = 0;
10080 wxFSFile *arg1 = (wxFSFile *) 0 ;
10081 wxString *result = 0 ;
10082 void *argp1 = 0 ;
10083 int res1 = 0 ;
10084 PyObject *swig_obj[1] ;
10085
10086 if (!args) SWIG_fail;
10087 swig_obj[0] = args;
10088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10089 if (!SWIG_IsOK(res1)) {
10090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10091 }
10092 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 {
10096 wxString const &_result_ref = (arg1)->GetAnchor();
10097 result = (wxString *) &_result_ref;
10098 }
10099 wxPyEndAllowThreads(__tstate);
10100 if (PyErr_Occurred()) SWIG_fail;
10101 }
10102 {
10103 #if wxUSE_UNICODE
10104 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10105 #else
10106 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10107 #endif
10108 }
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10116 PyObject *resultobj = 0;
10117 wxFSFile *arg1 = (wxFSFile *) 0 ;
10118 wxDateTime result;
10119 void *argp1 = 0 ;
10120 int res1 = 0 ;
10121 PyObject *swig_obj[1] ;
10122
10123 if (!args) SWIG_fail;
10124 swig_obj[0] = args;
10125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10126 if (!SWIG_IsOK(res1)) {
10127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10128 }
10129 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10130 {
10131 PyThreadState* __tstate = wxPyBeginAllowThreads();
10132 result = (arg1)->GetModificationTime();
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10137 return resultobj;
10138 fail:
10139 return NULL;
10140 }
10141
10142
10143 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10144 PyObject *obj;
10145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10146 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10147 return SWIG_Py_Void();
10148 }
10149
10150 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10151 return SWIG_Python_InitShadowInstance(args);
10152 }
10153
10154 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10155 PyObject *resultobj = 0;
10156 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10157 void *argp1 = 0 ;
10158 int res1 = 0 ;
10159 PyObject *swig_obj[1] ;
10160
10161 if (!args) SWIG_fail;
10162 swig_obj[0] = args;
10163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10164 if (!SWIG_IsOK(res1)) {
10165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10166 }
10167 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10168 {
10169 PyThreadState* __tstate = wxPyBeginAllowThreads();
10170 delete arg1;
10171
10172 wxPyEndAllowThreads(__tstate);
10173 if (PyErr_Occurred()) SWIG_fail;
10174 }
10175 resultobj = SWIG_Py_Void();
10176 return resultobj;
10177 fail:
10178 return NULL;
10179 }
10180
10181
10182 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10183 PyObject *obj;
10184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10185 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10186 return SWIG_Py_Void();
10187 }
10188
10189 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10190 PyObject *resultobj = 0;
10191 wxPyFileSystemHandler *result = 0 ;
10192
10193 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10194 {
10195 PyThreadState* __tstate = wxPyBeginAllowThreads();
10196 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10197 wxPyEndAllowThreads(__tstate);
10198 if (PyErr_Occurred()) SWIG_fail;
10199 }
10200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10201 return resultobj;
10202 fail:
10203 return NULL;
10204 }
10205
10206
10207 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10208 PyObject *resultobj = 0;
10209 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10210 PyObject *arg2 = (PyObject *) 0 ;
10211 PyObject *arg3 = (PyObject *) 0 ;
10212 void *argp1 = 0 ;
10213 int res1 = 0 ;
10214 PyObject * obj0 = 0 ;
10215 PyObject * obj1 = 0 ;
10216 PyObject * obj2 = 0 ;
10217 char * kwnames[] = {
10218 (char *) "self",(char *) "self",(char *) "_class", NULL
10219 };
10220
10221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10223 if (!SWIG_IsOK(res1)) {
10224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10225 }
10226 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10227 arg2 = obj1;
10228 arg3 = obj2;
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 (arg1)->_setCallbackInfo(arg2,arg3);
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 resultobj = SWIG_Py_Void();
10236 return resultobj;
10237 fail:
10238 return NULL;
10239 }
10240
10241
10242 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10243 PyObject *resultobj = 0;
10244 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10245 wxString *arg2 = 0 ;
10246 bool result;
10247 void *argp1 = 0 ;
10248 int res1 = 0 ;
10249 bool temp2 = false ;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 char * kwnames[] = {
10253 (char *) "self",(char *) "location", NULL
10254 };
10255
10256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10258 if (!SWIG_IsOK(res1)) {
10259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10260 }
10261 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10262 {
10263 arg2 = wxString_in_helper(obj1);
10264 if (arg2 == NULL) SWIG_fail;
10265 temp2 = true;
10266 }
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10270 wxPyEndAllowThreads(__tstate);
10271 if (PyErr_Occurred()) SWIG_fail;
10272 }
10273 {
10274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10275 }
10276 {
10277 if (temp2)
10278 delete arg2;
10279 }
10280 return resultobj;
10281 fail:
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return NULL;
10287 }
10288
10289
10290 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj = 0;
10292 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10293 wxFileSystem *arg2 = 0 ;
10294 wxString *arg3 = 0 ;
10295 wxFSFile *result = 0 ;
10296 void *argp1 = 0 ;
10297 int res1 = 0 ;
10298 void *argp2 = 0 ;
10299 int res2 = 0 ;
10300 bool temp3 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 PyObject * obj2 = 0 ;
10304 char * kwnames[] = {
10305 (char *) "self",(char *) "fs",(char *) "location", NULL
10306 };
10307
10308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10310 if (!SWIG_IsOK(res1)) {
10311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10312 }
10313 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10314 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10315 if (!SWIG_IsOK(res2)) {
10316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10317 }
10318 if (!argp2) {
10319 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10320 }
10321 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10322 {
10323 arg3 = wxString_in_helper(obj2);
10324 if (arg3 == NULL) SWIG_fail;
10325 temp3 = true;
10326 }
10327 {
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 {
10334 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10335 }
10336 {
10337 if (temp3)
10338 delete arg3;
10339 }
10340 return resultobj;
10341 fail:
10342 {
10343 if (temp3)
10344 delete arg3;
10345 }
10346 return NULL;
10347 }
10348
10349
10350 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj = 0;
10352 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10353 wxString *arg2 = 0 ;
10354 int arg3 = (int) 0 ;
10355 wxString result;
10356 void *argp1 = 0 ;
10357 int res1 = 0 ;
10358 bool temp2 = false ;
10359 int val3 ;
10360 int ecode3 = 0 ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 PyObject * obj2 = 0 ;
10364 char * kwnames[] = {
10365 (char *) "self",(char *) "spec",(char *) "flags", NULL
10366 };
10367
10368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10370 if (!SWIG_IsOK(res1)) {
10371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10372 }
10373 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10374 {
10375 arg2 = wxString_in_helper(obj1);
10376 if (arg2 == NULL) SWIG_fail;
10377 temp2 = true;
10378 }
10379 if (obj2) {
10380 ecode3 = SWIG_AsVal_int(obj2, &val3);
10381 if (!SWIG_IsOK(ecode3)) {
10382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10383 }
10384 arg3 = static_cast< int >(val3);
10385 }
10386 {
10387 PyThreadState* __tstate = wxPyBeginAllowThreads();
10388 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10389 wxPyEndAllowThreads(__tstate);
10390 if (PyErr_Occurred()) SWIG_fail;
10391 }
10392 {
10393 #if wxUSE_UNICODE
10394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10395 #else
10396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10397 #endif
10398 }
10399 {
10400 if (temp2)
10401 delete arg2;
10402 }
10403 return resultobj;
10404 fail:
10405 {
10406 if (temp2)
10407 delete arg2;
10408 }
10409 return NULL;
10410 }
10411
10412
10413 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10414 PyObject *resultobj = 0;
10415 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10416 wxString result;
10417 void *argp1 = 0 ;
10418 int res1 = 0 ;
10419 PyObject *swig_obj[1] ;
10420
10421 if (!args) SWIG_fail;
10422 swig_obj[0] = args;
10423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10424 if (!SWIG_IsOK(res1)) {
10425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10426 }
10427 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10428 {
10429 PyThreadState* __tstate = wxPyBeginAllowThreads();
10430 result = (arg1)->FindNext();
10431 wxPyEndAllowThreads(__tstate);
10432 if (PyErr_Occurred()) SWIG_fail;
10433 }
10434 {
10435 #if wxUSE_UNICODE
10436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10437 #else
10438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10439 #endif
10440 }
10441 return resultobj;
10442 fail:
10443 return NULL;
10444 }
10445
10446
10447 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10448 PyObject *resultobj = 0;
10449 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10450 wxString *arg2 = 0 ;
10451 wxString result;
10452 void *argp1 = 0 ;
10453 int res1 = 0 ;
10454 bool temp2 = false ;
10455 PyObject * obj0 = 0 ;
10456 PyObject * obj1 = 0 ;
10457 char * kwnames[] = {
10458 (char *) "self",(char *) "location", NULL
10459 };
10460
10461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10463 if (!SWIG_IsOK(res1)) {
10464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10465 }
10466 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10467 {
10468 arg2 = wxString_in_helper(obj1);
10469 if (arg2 == NULL) SWIG_fail;
10470 temp2 = true;
10471 }
10472 {
10473 PyThreadState* __tstate = wxPyBeginAllowThreads();
10474 result = (arg1)->GetProtocol((wxString const &)*arg2);
10475 wxPyEndAllowThreads(__tstate);
10476 if (PyErr_Occurred()) SWIG_fail;
10477 }
10478 {
10479 #if wxUSE_UNICODE
10480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10481 #else
10482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10483 #endif
10484 }
10485 {
10486 if (temp2)
10487 delete arg2;
10488 }
10489 return resultobj;
10490 fail:
10491 {
10492 if (temp2)
10493 delete arg2;
10494 }
10495 return NULL;
10496 }
10497
10498
10499 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10500 PyObject *resultobj = 0;
10501 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10502 wxString *arg2 = 0 ;
10503 wxString result;
10504 void *argp1 = 0 ;
10505 int res1 = 0 ;
10506 bool temp2 = false ;
10507 PyObject * obj0 = 0 ;
10508 PyObject * obj1 = 0 ;
10509 char * kwnames[] = {
10510 (char *) "self",(char *) "location", NULL
10511 };
10512
10513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10515 if (!SWIG_IsOK(res1)) {
10516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10517 }
10518 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10519 {
10520 arg2 = wxString_in_helper(obj1);
10521 if (arg2 == NULL) SWIG_fail;
10522 temp2 = true;
10523 }
10524 {
10525 PyThreadState* __tstate = wxPyBeginAllowThreads();
10526 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10527 wxPyEndAllowThreads(__tstate);
10528 if (PyErr_Occurred()) SWIG_fail;
10529 }
10530 {
10531 #if wxUSE_UNICODE
10532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10533 #else
10534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10535 #endif
10536 }
10537 {
10538 if (temp2)
10539 delete arg2;
10540 }
10541 return resultobj;
10542 fail:
10543 {
10544 if (temp2)
10545 delete arg2;
10546 }
10547 return NULL;
10548 }
10549
10550
10551 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj = 0;
10553 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10554 wxString *arg2 = 0 ;
10555 wxString result;
10556 void *argp1 = 0 ;
10557 int res1 = 0 ;
10558 bool temp2 = false ;
10559 PyObject * obj0 = 0 ;
10560 PyObject * obj1 = 0 ;
10561 char * kwnames[] = {
10562 (char *) "self",(char *) "location", NULL
10563 };
10564
10565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10567 if (!SWIG_IsOK(res1)) {
10568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10569 }
10570 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10571 {
10572 arg2 = wxString_in_helper(obj1);
10573 if (arg2 == NULL) SWIG_fail;
10574 temp2 = true;
10575 }
10576 {
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (arg1)->GetAnchor((wxString const &)*arg2);
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 {
10583 #if wxUSE_UNICODE
10584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10585 #else
10586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10587 #endif
10588 }
10589 {
10590 if (temp2)
10591 delete arg2;
10592 }
10593 return resultobj;
10594 fail:
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return NULL;
10600 }
10601
10602
10603 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10604 PyObject *resultobj = 0;
10605 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10606 wxString *arg2 = 0 ;
10607 wxString result;
10608 void *argp1 = 0 ;
10609 int res1 = 0 ;
10610 bool temp2 = false ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 char * kwnames[] = {
10614 (char *) "self",(char *) "location", NULL
10615 };
10616
10617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10619 if (!SWIG_IsOK(res1)) {
10620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10621 }
10622 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10623 {
10624 arg2 = wxString_in_helper(obj1);
10625 if (arg2 == NULL) SWIG_fail;
10626 temp2 = true;
10627 }
10628 {
10629 PyThreadState* __tstate = wxPyBeginAllowThreads();
10630 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10631 wxPyEndAllowThreads(__tstate);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 {
10635 #if wxUSE_UNICODE
10636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10637 #else
10638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10639 #endif
10640 }
10641 {
10642 if (temp2)
10643 delete arg2;
10644 }
10645 return resultobj;
10646 fail:
10647 {
10648 if (temp2)
10649 delete arg2;
10650 }
10651 return NULL;
10652 }
10653
10654
10655 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj = 0;
10657 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10658 wxString *arg2 = 0 ;
10659 wxString result;
10660 void *argp1 = 0 ;
10661 int res1 = 0 ;
10662 bool temp2 = false ;
10663 PyObject * obj0 = 0 ;
10664 PyObject * obj1 = 0 ;
10665 char * kwnames[] = {
10666 (char *) "self",(char *) "location", NULL
10667 };
10668
10669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10671 if (!SWIG_IsOK(res1)) {
10672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10673 }
10674 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10675 {
10676 arg2 = wxString_in_helper(obj1);
10677 if (arg2 == NULL) SWIG_fail;
10678 temp2 = true;
10679 }
10680 {
10681 PyThreadState* __tstate = wxPyBeginAllowThreads();
10682 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10683 wxPyEndAllowThreads(__tstate);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 {
10687 #if wxUSE_UNICODE
10688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10689 #else
10690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10691 #endif
10692 }
10693 {
10694 if (temp2)
10695 delete arg2;
10696 }
10697 return resultobj;
10698 fail:
10699 {
10700 if (temp2)
10701 delete arg2;
10702 }
10703 return NULL;
10704 }
10705
10706
10707 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10708 PyObject *obj;
10709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10710 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10711 return SWIG_Py_Void();
10712 }
10713
10714 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10715 return SWIG_Python_InitShadowInstance(args);
10716 }
10717
10718 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10719 PyObject *resultobj = 0;
10720 wxFileSystem *result = 0 ;
10721
10722 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10723 {
10724 PyThreadState* __tstate = wxPyBeginAllowThreads();
10725 result = (wxFileSystem *)new wxFileSystem();
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 {
10730 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10731 }
10732 return resultobj;
10733 fail:
10734 return NULL;
10735 }
10736
10737
10738 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10739 PyObject *resultobj = 0;
10740 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10741 void *argp1 = 0 ;
10742 int res1 = 0 ;
10743 PyObject *swig_obj[1] ;
10744
10745 if (!args) SWIG_fail;
10746 swig_obj[0] = args;
10747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10748 if (!SWIG_IsOK(res1)) {
10749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10750 }
10751 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 delete arg1;
10755
10756 wxPyEndAllowThreads(__tstate);
10757 if (PyErr_Occurred()) SWIG_fail;
10758 }
10759 resultobj = SWIG_Py_Void();
10760 return resultobj;
10761 fail:
10762 return NULL;
10763 }
10764
10765
10766 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10767 PyObject *resultobj = 0;
10768 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10769 wxString *arg2 = 0 ;
10770 bool arg3 = (bool) false ;
10771 void *argp1 = 0 ;
10772 int res1 = 0 ;
10773 bool temp2 = false ;
10774 bool val3 ;
10775 int ecode3 = 0 ;
10776 PyObject * obj0 = 0 ;
10777 PyObject * obj1 = 0 ;
10778 PyObject * obj2 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10787 }
10788 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10789 {
10790 arg2 = wxString_in_helper(obj1);
10791 if (arg2 == NULL) SWIG_fail;
10792 temp2 = true;
10793 }
10794 if (obj2) {
10795 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10796 if (!SWIG_IsOK(ecode3)) {
10797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10798 }
10799 arg3 = static_cast< bool >(val3);
10800 }
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 resultobj = SWIG_Py_Void();
10808 {
10809 if (temp2)
10810 delete arg2;
10811 }
10812 return resultobj;
10813 fail:
10814 {
10815 if (temp2)
10816 delete arg2;
10817 }
10818 return NULL;
10819 }
10820
10821
10822 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10823 PyObject *resultobj = 0;
10824 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10825 wxString result;
10826 void *argp1 = 0 ;
10827 int res1 = 0 ;
10828 PyObject *swig_obj[1] ;
10829
10830 if (!args) SWIG_fail;
10831 swig_obj[0] = args;
10832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10833 if (!SWIG_IsOK(res1)) {
10834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10835 }
10836 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10837 {
10838 PyThreadState* __tstate = wxPyBeginAllowThreads();
10839 result = (arg1)->GetPath();
10840 wxPyEndAllowThreads(__tstate);
10841 if (PyErr_Occurred()) SWIG_fail;
10842 }
10843 {
10844 #if wxUSE_UNICODE
10845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10846 #else
10847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10848 #endif
10849 }
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj = 0;
10858 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10859 wxString *arg2 = 0 ;
10860 wxFSFile *result = 0 ;
10861 void *argp1 = 0 ;
10862 int res1 = 0 ;
10863 bool temp2 = false ;
10864 PyObject * obj0 = 0 ;
10865 PyObject * obj1 = 0 ;
10866 char * kwnames[] = {
10867 (char *) "self",(char *) "location", NULL
10868 };
10869
10870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10874 }
10875 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10876 {
10877 arg2 = wxString_in_helper(obj1);
10878 if (arg2 == NULL) SWIG_fail;
10879 temp2 = true;
10880 }
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10884 wxPyEndAllowThreads(__tstate);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 {
10888 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10889 }
10890 {
10891 if (temp2)
10892 delete arg2;
10893 }
10894 return resultobj;
10895 fail:
10896 {
10897 if (temp2)
10898 delete arg2;
10899 }
10900 return NULL;
10901 }
10902
10903
10904 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10905 PyObject *resultobj = 0;
10906 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10907 wxString *arg2 = 0 ;
10908 int arg3 = (int) 0 ;
10909 wxString result;
10910 void *argp1 = 0 ;
10911 int res1 = 0 ;
10912 bool temp2 = false ;
10913 int val3 ;
10914 int ecode3 = 0 ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 PyObject * obj2 = 0 ;
10918 char * kwnames[] = {
10919 (char *) "self",(char *) "spec",(char *) "flags", NULL
10920 };
10921
10922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10924 if (!SWIG_IsOK(res1)) {
10925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10926 }
10927 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10928 {
10929 arg2 = wxString_in_helper(obj1);
10930 if (arg2 == NULL) SWIG_fail;
10931 temp2 = true;
10932 }
10933 if (obj2) {
10934 ecode3 = SWIG_AsVal_int(obj2, &val3);
10935 if (!SWIG_IsOK(ecode3)) {
10936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10937 }
10938 arg3 = static_cast< int >(val3);
10939 }
10940 {
10941 PyThreadState* __tstate = wxPyBeginAllowThreads();
10942 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10943 wxPyEndAllowThreads(__tstate);
10944 if (PyErr_Occurred()) SWIG_fail;
10945 }
10946 {
10947 #if wxUSE_UNICODE
10948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10949 #else
10950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10951 #endif
10952 }
10953 {
10954 if (temp2)
10955 delete arg2;
10956 }
10957 return resultobj;
10958 fail:
10959 {
10960 if (temp2)
10961 delete arg2;
10962 }
10963 return NULL;
10964 }
10965
10966
10967 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10968 PyObject *resultobj = 0;
10969 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10970 wxString result;
10971 void *argp1 = 0 ;
10972 int res1 = 0 ;
10973 PyObject *swig_obj[1] ;
10974
10975 if (!args) SWIG_fail;
10976 swig_obj[0] = args;
10977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10980 }
10981 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10982 {
10983 PyThreadState* __tstate = wxPyBeginAllowThreads();
10984 result = (arg1)->FindNext();
10985 wxPyEndAllowThreads(__tstate);
10986 if (PyErr_Occurred()) SWIG_fail;
10987 }
10988 {
10989 #if wxUSE_UNICODE
10990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10991 #else
10992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10993 #endif
10994 }
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj = 0;
11003 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11004 int res1 = 0 ;
11005 PyObject * obj0 = 0 ;
11006 char * kwnames[] = {
11007 (char *) "handler", NULL
11008 };
11009
11010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11011 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11012 if (!SWIG_IsOK(res1)) {
11013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11014 }
11015 {
11016 PyThreadState* __tstate = wxPyBeginAllowThreads();
11017 wxFileSystem::AddHandler(arg1);
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 resultobj = SWIG_Py_Void();
11022 return resultobj;
11023 fail:
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11031 wxFileSystemHandler *result = 0 ;
11032 void *argp1 = 0 ;
11033 int res1 = 0 ;
11034 PyObject * obj0 = 0 ;
11035 char * kwnames[] = {
11036 (char *) "handler", NULL
11037 };
11038
11039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11041 if (!SWIG_IsOK(res1)) {
11042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11043 }
11044 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11045 {
11046 PyThreadState* __tstate = wxPyBeginAllowThreads();
11047 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11052 return resultobj;
11053 fail:
11054 return NULL;
11055 }
11056
11057
11058 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11059 PyObject *resultobj = 0;
11060
11061 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11062 {
11063 PyThreadState* __tstate = wxPyBeginAllowThreads();
11064 wxFileSystem::CleanUpHandlers();
11065 wxPyEndAllowThreads(__tstate);
11066 if (PyErr_Occurred()) SWIG_fail;
11067 }
11068 resultobj = SWIG_Py_Void();
11069 return resultobj;
11070 fail:
11071 return NULL;
11072 }
11073
11074
11075 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11076 PyObject *resultobj = 0;
11077 wxString *arg1 = 0 ;
11078 wxString result;
11079 bool temp1 = false ;
11080 PyObject * obj0 = 0 ;
11081 char * kwnames[] = {
11082 (char *) "filename", NULL
11083 };
11084
11085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11086 {
11087 arg1 = wxString_in_helper(obj0);
11088 if (arg1 == NULL) SWIG_fail;
11089 temp1 = true;
11090 }
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 {
11098 #if wxUSE_UNICODE
11099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11100 #else
11101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11102 #endif
11103 }
11104 {
11105 if (temp1)
11106 delete arg1;
11107 }
11108 return resultobj;
11109 fail:
11110 {
11111 if (temp1)
11112 delete arg1;
11113 }
11114 return NULL;
11115 }
11116
11117
11118 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11119 PyObject *resultobj = 0;
11120 wxString *arg1 = 0 ;
11121 wxString result;
11122 bool temp1 = false ;
11123 PyObject * obj0 = 0 ;
11124 char * kwnames[] = {
11125 (char *) "url", NULL
11126 };
11127
11128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11129 {
11130 arg1 = wxString_in_helper(obj0);
11131 if (arg1 == NULL) SWIG_fail;
11132 temp1 = true;
11133 }
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 {
11141 #if wxUSE_UNICODE
11142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11143 #else
11144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11145 #endif
11146 }
11147 {
11148 if (temp1)
11149 delete arg1;
11150 }
11151 return resultobj;
11152 fail:
11153 {
11154 if (temp1)
11155 delete arg1;
11156 }
11157 return NULL;
11158 }
11159
11160
11161 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11162 PyObject *obj;
11163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11164 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11165 return SWIG_Py_Void();
11166 }
11167
11168 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11169 return SWIG_Python_InitShadowInstance(args);
11170 }
11171
11172 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11173 PyObject *resultobj = 0;
11174 wxInternetFSHandler *result = 0 ;
11175
11176 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11177 {
11178 PyThreadState* __tstate = wxPyBeginAllowThreads();
11179 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11180 wxPyEndAllowThreads(__tstate);
11181 if (PyErr_Occurred()) SWIG_fail;
11182 }
11183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11184 return resultobj;
11185 fail:
11186 return NULL;
11187 }
11188
11189
11190 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj = 0;
11192 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11193 wxString *arg2 = 0 ;
11194 bool result;
11195 void *argp1 = 0 ;
11196 int res1 = 0 ;
11197 bool temp2 = false ;
11198 PyObject * obj0 = 0 ;
11199 PyObject * obj1 = 0 ;
11200 char * kwnames[] = {
11201 (char *) "self",(char *) "location", NULL
11202 };
11203
11204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11206 if (!SWIG_IsOK(res1)) {
11207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11208 }
11209 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11210 {
11211 arg2 = wxString_in_helper(obj1);
11212 if (arg2 == NULL) SWIG_fail;
11213 temp2 = true;
11214 }
11215 {
11216 PyThreadState* __tstate = wxPyBeginAllowThreads();
11217 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 {
11222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11223 }
11224 {
11225 if (temp2)
11226 delete arg2;
11227 }
11228 return resultobj;
11229 fail:
11230 {
11231 if (temp2)
11232 delete arg2;
11233 }
11234 return NULL;
11235 }
11236
11237
11238 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11239 PyObject *resultobj = 0;
11240 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11241 wxFileSystem *arg2 = 0 ;
11242 wxString *arg3 = 0 ;
11243 wxFSFile *result = 0 ;
11244 void *argp1 = 0 ;
11245 int res1 = 0 ;
11246 void *argp2 = 0 ;
11247 int res2 = 0 ;
11248 bool temp3 = false ;
11249 PyObject * obj0 = 0 ;
11250 PyObject * obj1 = 0 ;
11251 PyObject * obj2 = 0 ;
11252 char * kwnames[] = {
11253 (char *) "self",(char *) "fs",(char *) "location", NULL
11254 };
11255
11256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11258 if (!SWIG_IsOK(res1)) {
11259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11260 }
11261 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11262 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11263 if (!SWIG_IsOK(res2)) {
11264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11265 }
11266 if (!argp2) {
11267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11268 }
11269 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11270 {
11271 arg3 = wxString_in_helper(obj2);
11272 if (arg3 == NULL) SWIG_fail;
11273 temp3 = true;
11274 }
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11278 wxPyEndAllowThreads(__tstate);
11279 if (PyErr_Occurred()) SWIG_fail;
11280 }
11281 {
11282 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11283 }
11284 {
11285 if (temp3)
11286 delete arg3;
11287 }
11288 return resultobj;
11289 fail:
11290 {
11291 if (temp3)
11292 delete arg3;
11293 }
11294 return NULL;
11295 }
11296
11297
11298 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11299 PyObject *obj;
11300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11301 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11302 return SWIG_Py_Void();
11303 }
11304
11305 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11306 return SWIG_Python_InitShadowInstance(args);
11307 }
11308
11309 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11310 PyObject *resultobj = 0;
11311 wxZipFSHandler *result = 0 ;
11312
11313 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11314 {
11315 PyThreadState* __tstate = wxPyBeginAllowThreads();
11316 result = (wxZipFSHandler *)new wxZipFSHandler();
11317 wxPyEndAllowThreads(__tstate);
11318 if (PyErr_Occurred()) SWIG_fail;
11319 }
11320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj = 0;
11329 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11330 wxString *arg2 = 0 ;
11331 bool result;
11332 void *argp1 = 0 ;
11333 int res1 = 0 ;
11334 bool temp2 = false ;
11335 PyObject * obj0 = 0 ;
11336 PyObject * obj1 = 0 ;
11337 char * kwnames[] = {
11338 (char *) "self",(char *) "location", NULL
11339 };
11340
11341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11343 if (!SWIG_IsOK(res1)) {
11344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11345 }
11346 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11347 {
11348 arg2 = wxString_in_helper(obj1);
11349 if (arg2 == NULL) SWIG_fail;
11350 temp2 = true;
11351 }
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11360 }
11361 {
11362 if (temp2)
11363 delete arg2;
11364 }
11365 return resultobj;
11366 fail:
11367 {
11368 if (temp2)
11369 delete arg2;
11370 }
11371 return NULL;
11372 }
11373
11374
11375 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj = 0;
11377 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11378 wxFileSystem *arg2 = 0 ;
11379 wxString *arg3 = 0 ;
11380 wxFSFile *result = 0 ;
11381 void *argp1 = 0 ;
11382 int res1 = 0 ;
11383 void *argp2 = 0 ;
11384 int res2 = 0 ;
11385 bool temp3 = false ;
11386 PyObject * obj0 = 0 ;
11387 PyObject * obj1 = 0 ;
11388 PyObject * obj2 = 0 ;
11389 char * kwnames[] = {
11390 (char *) "self",(char *) "fs",(char *) "location", NULL
11391 };
11392
11393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11395 if (!SWIG_IsOK(res1)) {
11396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11397 }
11398 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11399 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11400 if (!SWIG_IsOK(res2)) {
11401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11402 }
11403 if (!argp2) {
11404 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11405 }
11406 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11407 {
11408 arg3 = wxString_in_helper(obj2);
11409 if (arg3 == NULL) SWIG_fail;
11410 temp3 = true;
11411 }
11412 {
11413 PyThreadState* __tstate = wxPyBeginAllowThreads();
11414 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11415 wxPyEndAllowThreads(__tstate);
11416 if (PyErr_Occurred()) SWIG_fail;
11417 }
11418 {
11419 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11420 }
11421 {
11422 if (temp3)
11423 delete arg3;
11424 }
11425 return resultobj;
11426 fail:
11427 {
11428 if (temp3)
11429 delete arg3;
11430 }
11431 return NULL;
11432 }
11433
11434
11435 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj = 0;
11437 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11438 wxString *arg2 = 0 ;
11439 int arg3 = (int) 0 ;
11440 wxString result;
11441 void *argp1 = 0 ;
11442 int res1 = 0 ;
11443 bool temp2 = false ;
11444 int val3 ;
11445 int ecode3 = 0 ;
11446 PyObject * obj0 = 0 ;
11447 PyObject * obj1 = 0 ;
11448 PyObject * obj2 = 0 ;
11449 char * kwnames[] = {
11450 (char *) "self",(char *) "spec",(char *) "flags", NULL
11451 };
11452
11453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11455 if (!SWIG_IsOK(res1)) {
11456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11457 }
11458 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11459 {
11460 arg2 = wxString_in_helper(obj1);
11461 if (arg2 == NULL) SWIG_fail;
11462 temp2 = true;
11463 }
11464 if (obj2) {
11465 ecode3 = SWIG_AsVal_int(obj2, &val3);
11466 if (!SWIG_IsOK(ecode3)) {
11467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11468 }
11469 arg3 = static_cast< int >(val3);
11470 }
11471 {
11472 PyThreadState* __tstate = wxPyBeginAllowThreads();
11473 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11474 wxPyEndAllowThreads(__tstate);
11475 if (PyErr_Occurred()) SWIG_fail;
11476 }
11477 {
11478 #if wxUSE_UNICODE
11479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11480 #else
11481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11482 #endif
11483 }
11484 {
11485 if (temp2)
11486 delete arg2;
11487 }
11488 return resultobj;
11489 fail:
11490 {
11491 if (temp2)
11492 delete arg2;
11493 }
11494 return NULL;
11495 }
11496
11497
11498 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11499 PyObject *resultobj = 0;
11500 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11501 wxString result;
11502 void *argp1 = 0 ;
11503 int res1 = 0 ;
11504 PyObject *swig_obj[1] ;
11505
11506 if (!args) SWIG_fail;
11507 swig_obj[0] = args;
11508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11509 if (!SWIG_IsOK(res1)) {
11510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11511 }
11512 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = (arg1)->FindNext();
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 {
11520 #if wxUSE_UNICODE
11521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11522 #else
11523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11524 #endif
11525 }
11526 return resultobj;
11527 fail:
11528 return NULL;
11529 }
11530
11531
11532 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11533 PyObject *obj;
11534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11535 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11536 return SWIG_Py_Void();
11537 }
11538
11539 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11540 return SWIG_Python_InitShadowInstance(args);
11541 }
11542
11543 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11544 PyObject *resultobj = 0;
11545 wxString *arg1 = 0 ;
11546 wxImage *arg2 = 0 ;
11547 long arg3 ;
11548 bool temp1 = false ;
11549 void *argp2 = 0 ;
11550 int res2 = 0 ;
11551 long val3 ;
11552 int ecode3 = 0 ;
11553 PyObject * obj0 = 0 ;
11554 PyObject * obj1 = 0 ;
11555 PyObject * obj2 = 0 ;
11556 char * kwnames[] = {
11557 (char *) "filename",(char *) "image",(char *) "type", NULL
11558 };
11559
11560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11561 {
11562 arg1 = wxString_in_helper(obj0);
11563 if (arg1 == NULL) SWIG_fail;
11564 temp1 = true;
11565 }
11566 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11567 if (!SWIG_IsOK(res2)) {
11568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11569 }
11570 if (!argp2) {
11571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11572 }
11573 arg2 = reinterpret_cast< wxImage * >(argp2);
11574 ecode3 = SWIG_AsVal_long(obj2, &val3);
11575 if (!SWIG_IsOK(ecode3)) {
11576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11577 }
11578 arg3 = static_cast< long >(val3);
11579 {
11580 PyThreadState* __tstate = wxPyBeginAllowThreads();
11581 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11582 wxPyEndAllowThreads(__tstate);
11583 if (PyErr_Occurred()) SWIG_fail;
11584 }
11585 resultobj = SWIG_Py_Void();
11586 {
11587 if (temp1)
11588 delete arg1;
11589 }
11590 return resultobj;
11591 fail:
11592 {
11593 if (temp1)
11594 delete arg1;
11595 }
11596 return NULL;
11597 }
11598
11599
11600 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11601 PyObject *resultobj = 0;
11602 wxString *arg1 = 0 ;
11603 wxBitmap *arg2 = 0 ;
11604 long arg3 ;
11605 bool temp1 = false ;
11606 void *argp2 = 0 ;
11607 int res2 = 0 ;
11608 long val3 ;
11609 int ecode3 = 0 ;
11610 PyObject * obj0 = 0 ;
11611 PyObject * obj1 = 0 ;
11612 PyObject * obj2 = 0 ;
11613 char * kwnames[] = {
11614 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11615 };
11616
11617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11618 {
11619 arg1 = wxString_in_helper(obj0);
11620 if (arg1 == NULL) SWIG_fail;
11621 temp1 = true;
11622 }
11623 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11624 if (!SWIG_IsOK(res2)) {
11625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11626 }
11627 if (!argp2) {
11628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11629 }
11630 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11631 ecode3 = SWIG_AsVal_long(obj2, &val3);
11632 if (!SWIG_IsOK(ecode3)) {
11633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11634 }
11635 arg3 = static_cast< long >(val3);
11636 {
11637 PyThreadState* __tstate = wxPyBeginAllowThreads();
11638 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 resultobj = SWIG_Py_Void();
11643 {
11644 if (temp1)
11645 delete arg1;
11646 }
11647 return resultobj;
11648 fail:
11649 {
11650 if (temp1)
11651 delete arg1;
11652 }
11653 return NULL;
11654 }
11655
11656
11657 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11658 PyObject *resultobj = 0;
11659 wxString *arg1 = 0 ;
11660 PyObject *arg2 = (PyObject *) 0 ;
11661 bool temp1 = false ;
11662 PyObject * obj0 = 0 ;
11663 PyObject * obj1 = 0 ;
11664 char * kwnames[] = {
11665 (char *) "filename",(char *) "data", NULL
11666 };
11667
11668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11669 {
11670 arg1 = wxString_in_helper(obj0);
11671 if (arg1 == NULL) SWIG_fail;
11672 temp1 = true;
11673 }
11674 arg2 = obj1;
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 resultobj = SWIG_Py_Void();
11682 {
11683 if (temp1)
11684 delete arg1;
11685 }
11686 return resultobj;
11687 fail:
11688 {
11689 if (temp1)
11690 delete arg1;
11691 }
11692 return NULL;
11693 }
11694
11695
11696 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11697 PyObject *resultobj = 0;
11698 wxMemoryFSHandler *result = 0 ;
11699
11700 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11715 PyObject *resultobj = 0;
11716 wxString *arg1 = 0 ;
11717 bool temp1 = false ;
11718 PyObject * obj0 = 0 ;
11719 char * kwnames[] = {
11720 (char *) "filename", NULL
11721 };
11722
11723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11724 {
11725 arg1 = wxString_in_helper(obj0);
11726 if (arg1 == NULL) SWIG_fail;
11727 temp1 = true;
11728 }
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11732 wxPyEndAllowThreads(__tstate);
11733 if (PyErr_Occurred()) SWIG_fail;
11734 }
11735 resultobj = SWIG_Py_Void();
11736 {
11737 if (temp1)
11738 delete arg1;
11739 }
11740 return resultobj;
11741 fail:
11742 {
11743 if (temp1)
11744 delete arg1;
11745 }
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11751 PyObject *resultobj = 0;
11752 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11753 wxString *arg2 = 0 ;
11754 bool result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 bool temp2 = false ;
11758 PyObject * obj0 = 0 ;
11759 PyObject * obj1 = 0 ;
11760 char * kwnames[] = {
11761 (char *) "self",(char *) "location", NULL
11762 };
11763
11764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11766 if (!SWIG_IsOK(res1)) {
11767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11768 }
11769 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11770 {
11771 arg2 = wxString_in_helper(obj1);
11772 if (arg2 == NULL) SWIG_fail;
11773 temp2 = true;
11774 }
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11783 }
11784 {
11785 if (temp2)
11786 delete arg2;
11787 }
11788 return resultobj;
11789 fail:
11790 {
11791 if (temp2)
11792 delete arg2;
11793 }
11794 return NULL;
11795 }
11796
11797
11798 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11799 PyObject *resultobj = 0;
11800 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11801 wxFileSystem *arg2 = 0 ;
11802 wxString *arg3 = 0 ;
11803 wxFSFile *result = 0 ;
11804 void *argp1 = 0 ;
11805 int res1 = 0 ;
11806 void *argp2 = 0 ;
11807 int res2 = 0 ;
11808 bool temp3 = false ;
11809 PyObject * obj0 = 0 ;
11810 PyObject * obj1 = 0 ;
11811 PyObject * obj2 = 0 ;
11812 char * kwnames[] = {
11813 (char *) "self",(char *) "fs",(char *) "location", NULL
11814 };
11815
11816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11820 }
11821 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11822 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11823 if (!SWIG_IsOK(res2)) {
11824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11825 }
11826 if (!argp2) {
11827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11828 }
11829 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11830 {
11831 arg3 = wxString_in_helper(obj2);
11832 if (arg3 == NULL) SWIG_fail;
11833 temp3 = true;
11834 }
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 {
11842 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11843 }
11844 {
11845 if (temp3)
11846 delete arg3;
11847 }
11848 return resultobj;
11849 fail:
11850 {
11851 if (temp3)
11852 delete arg3;
11853 }
11854 return NULL;
11855 }
11856
11857
11858 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11859 PyObject *resultobj = 0;
11860 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11861 wxString *arg2 = 0 ;
11862 int arg3 = (int) 0 ;
11863 wxString result;
11864 void *argp1 = 0 ;
11865 int res1 = 0 ;
11866 bool temp2 = false ;
11867 int val3 ;
11868 int ecode3 = 0 ;
11869 PyObject * obj0 = 0 ;
11870 PyObject * obj1 = 0 ;
11871 PyObject * obj2 = 0 ;
11872 char * kwnames[] = {
11873 (char *) "self",(char *) "spec",(char *) "flags", NULL
11874 };
11875
11876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11878 if (!SWIG_IsOK(res1)) {
11879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11880 }
11881 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11882 {
11883 arg2 = wxString_in_helper(obj1);
11884 if (arg2 == NULL) SWIG_fail;
11885 temp2 = true;
11886 }
11887 if (obj2) {
11888 ecode3 = SWIG_AsVal_int(obj2, &val3);
11889 if (!SWIG_IsOK(ecode3)) {
11890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11891 }
11892 arg3 = static_cast< int >(val3);
11893 }
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 #if wxUSE_UNICODE
11902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11903 #else
11904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11905 #endif
11906 }
11907 {
11908 if (temp2)
11909 delete arg2;
11910 }
11911 return resultobj;
11912 fail:
11913 {
11914 if (temp2)
11915 delete arg2;
11916 }
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11922 PyObject *resultobj = 0;
11923 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11924 wxString result;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 PyObject *swig_obj[1] ;
11928
11929 if (!args) SWIG_fail;
11930 swig_obj[0] = args;
11931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11932 if (!SWIG_IsOK(res1)) {
11933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11934 }
11935 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (arg1)->FindNext();
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 #if wxUSE_UNICODE
11944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11945 #else
11946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11947 #endif
11948 }
11949 return resultobj;
11950 fail:
11951 return NULL;
11952 }
11953
11954
11955 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11956 PyObject *obj;
11957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11958 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11959 return SWIG_Py_Void();
11960 }
11961
11962 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11963 return SWIG_Python_InitShadowInstance(args);
11964 }
11965
11966 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11967 PyObject *resultobj = 0;
11968 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11969 wxString result;
11970 void *argp1 = 0 ;
11971 int res1 = 0 ;
11972 PyObject *swig_obj[1] ;
11973
11974 if (!args) SWIG_fail;
11975 swig_obj[0] = args;
11976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11977 if (!SWIG_IsOK(res1)) {
11978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11979 }
11980 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11981 {
11982 PyThreadState* __tstate = wxPyBeginAllowThreads();
11983 result = (arg1)->GetName();
11984 wxPyEndAllowThreads(__tstate);
11985 if (PyErr_Occurred()) SWIG_fail;
11986 }
11987 {
11988 #if wxUSE_UNICODE
11989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11990 #else
11991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11992 #endif
11993 }
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12001 PyObject *resultobj = 0;
12002 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12003 wxString result;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 PyObject *swig_obj[1] ;
12007
12008 if (!args) SWIG_fail;
12009 swig_obj[0] = args;
12010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12011 if (!SWIG_IsOK(res1)) {
12012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12013 }
12014 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (arg1)->GetExtension();
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 {
12022 #if wxUSE_UNICODE
12023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12024 #else
12025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12026 #endif
12027 }
12028 return resultobj;
12029 fail:
12030 return NULL;
12031 }
12032
12033
12034 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12035 PyObject *resultobj = 0;
12036 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12037 long result;
12038 void *argp1 = 0 ;
12039 int res1 = 0 ;
12040 PyObject *swig_obj[1] ;
12041
12042 if (!args) SWIG_fail;
12043 swig_obj[0] = args;
12044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12045 if (!SWIG_IsOK(res1)) {
12046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12047 }
12048 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (long)(arg1)->GetType();
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 resultobj = SWIG_From_long(static_cast< long >(result));
12056 return resultobj;
12057 fail:
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12063 PyObject *resultobj = 0;
12064 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12065 wxString result;
12066 void *argp1 = 0 ;
12067 int res1 = 0 ;
12068 PyObject *swig_obj[1] ;
12069
12070 if (!args) SWIG_fail;
12071 swig_obj[0] = args;
12072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12073 if (!SWIG_IsOK(res1)) {
12074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12075 }
12076 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 result = (arg1)->GetMimeType();
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 {
12084 #if wxUSE_UNICODE
12085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12086 #else
12087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12088 #endif
12089 }
12090 return resultobj;
12091 fail:
12092 return NULL;
12093 }
12094
12095
12096 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12097 PyObject *resultobj = 0;
12098 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12099 wxString *arg2 = 0 ;
12100 bool result;
12101 void *argp1 = 0 ;
12102 int res1 = 0 ;
12103 bool temp2 = false ;
12104 PyObject * obj0 = 0 ;
12105 PyObject * obj1 = 0 ;
12106 char * kwnames[] = {
12107 (char *) "self",(char *) "name", NULL
12108 };
12109
12110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12112 if (!SWIG_IsOK(res1)) {
12113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12114 }
12115 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12116 {
12117 arg2 = wxString_in_helper(obj1);
12118 if (arg2 == NULL) SWIG_fail;
12119 temp2 = true;
12120 }
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 {
12128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12129 }
12130 {
12131 if (temp2)
12132 delete arg2;
12133 }
12134 return resultobj;
12135 fail:
12136 {
12137 if (temp2)
12138 delete arg2;
12139 }
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12145 PyObject *resultobj = 0;
12146 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12147 wxInputStream *arg2 = 0 ;
12148 bool result;
12149 void *argp1 = 0 ;
12150 int res1 = 0 ;
12151 wxPyInputStream *temp2 ;
12152 bool created2 ;
12153 PyObject * obj0 = 0 ;
12154 PyObject * obj1 = 0 ;
12155 char * kwnames[] = {
12156 (char *) "self",(char *) "stream", NULL
12157 };
12158
12159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12161 if (!SWIG_IsOK(res1)) {
12162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12163 }
12164 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12165 {
12166 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12167 arg2 = temp2->m_wxis;
12168 created2 = false;
12169 } else {
12170 PyErr_Clear(); // clear the failure of the wxPyConvert above
12171 arg2 = wxPyCBInputStream_create(obj1, false);
12172 if (arg2 == NULL) {
12173 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12174 SWIG_fail;
12175 }
12176 created2 = true;
12177 }
12178 }
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = (bool)(arg1)->CanRead(*arg2);
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 {
12186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12187 }
12188 {
12189 if (created2) delete arg2;
12190 }
12191 return resultobj;
12192 fail:
12193 {
12194 if (created2) delete arg2;
12195 }
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj = 0;
12202 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12203 wxString *arg2 = 0 ;
12204 void *argp1 = 0 ;
12205 int res1 = 0 ;
12206 bool temp2 = false ;
12207 PyObject * obj0 = 0 ;
12208 PyObject * obj1 = 0 ;
12209 char * kwnames[] = {
12210 (char *) "self",(char *) "name", NULL
12211 };
12212
12213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12215 if (!SWIG_IsOK(res1)) {
12216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12217 }
12218 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12219 {
12220 arg2 = wxString_in_helper(obj1);
12221 if (arg2 == NULL) SWIG_fail;
12222 temp2 = true;
12223 }
12224 {
12225 PyThreadState* __tstate = wxPyBeginAllowThreads();
12226 (arg1)->SetName((wxString const &)*arg2);
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 resultobj = SWIG_Py_Void();
12231 {
12232 if (temp2)
12233 delete arg2;
12234 }
12235 return resultobj;
12236 fail:
12237 {
12238 if (temp2)
12239 delete arg2;
12240 }
12241 return NULL;
12242 }
12243
12244
12245 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj = 0;
12247 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12248 wxString *arg2 = 0 ;
12249 void *argp1 = 0 ;
12250 int res1 = 0 ;
12251 bool temp2 = false ;
12252 PyObject * obj0 = 0 ;
12253 PyObject * obj1 = 0 ;
12254 char * kwnames[] = {
12255 (char *) "self",(char *) "extension", NULL
12256 };
12257
12258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12260 if (!SWIG_IsOK(res1)) {
12261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12262 }
12263 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12264 {
12265 arg2 = wxString_in_helper(obj1);
12266 if (arg2 == NULL) SWIG_fail;
12267 temp2 = true;
12268 }
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 (arg1)->SetExtension((wxString const &)*arg2);
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 resultobj = SWIG_Py_Void();
12276 {
12277 if (temp2)
12278 delete arg2;
12279 }
12280 return resultobj;
12281 fail:
12282 {
12283 if (temp2)
12284 delete arg2;
12285 }
12286 return NULL;
12287 }
12288
12289
12290 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj = 0;
12292 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12293 long arg2 ;
12294 void *argp1 = 0 ;
12295 int res1 = 0 ;
12296 long val2 ;
12297 int ecode2 = 0 ;
12298 PyObject * obj0 = 0 ;
12299 PyObject * obj1 = 0 ;
12300 char * kwnames[] = {
12301 (char *) "self",(char *) "type", NULL
12302 };
12303
12304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12306 if (!SWIG_IsOK(res1)) {
12307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12308 }
12309 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12310 ecode2 = SWIG_AsVal_long(obj1, &val2);
12311 if (!SWIG_IsOK(ecode2)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12313 }
12314 arg2 = static_cast< long >(val2);
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 (arg1)->SetType(arg2);
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 resultobj = SWIG_Py_Void();
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12329 PyObject *resultobj = 0;
12330 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12331 wxString *arg2 = 0 ;
12332 void *argp1 = 0 ;
12333 int res1 = 0 ;
12334 bool temp2 = false ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 char * kwnames[] = {
12338 (char *) "self",(char *) "mimetype", NULL
12339 };
12340
12341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12343 if (!SWIG_IsOK(res1)) {
12344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12345 }
12346 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12347 {
12348 arg2 = wxString_in_helper(obj1);
12349 if (arg2 == NULL) SWIG_fail;
12350 temp2 = true;
12351 }
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 (arg1)->SetMimeType((wxString const &)*arg2);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_Py_Void();
12359 {
12360 if (temp2)
12361 delete arg2;
12362 }
12363 return resultobj;
12364 fail:
12365 {
12366 if (temp2)
12367 delete arg2;
12368 }
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12374 PyObject *obj;
12375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12376 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12377 return SWIG_Py_Void();
12378 }
12379
12380 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12381 PyObject *resultobj = 0;
12382 wxPyImageHandler *result = 0 ;
12383
12384 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 result = (wxPyImageHandler *)new wxPyImageHandler();
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12392 return resultobj;
12393 fail:
12394 return NULL;
12395 }
12396
12397
12398 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12399 PyObject *resultobj = 0;
12400 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12401 PyObject *arg2 = (PyObject *) 0 ;
12402 void *argp1 = 0 ;
12403 int res1 = 0 ;
12404 PyObject * obj0 = 0 ;
12405 PyObject * obj1 = 0 ;
12406 char * kwnames[] = {
12407 (char *) "self",(char *) "self", NULL
12408 };
12409
12410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12412 if (!SWIG_IsOK(res1)) {
12413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12414 }
12415 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12416 arg2 = obj1;
12417 {
12418 PyThreadState* __tstate = wxPyBeginAllowThreads();
12419 (arg1)->_SetSelf(arg2);
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 resultobj = SWIG_Py_Void();
12424 return resultobj;
12425 fail:
12426 return NULL;
12427 }
12428
12429
12430 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12431 PyObject *obj;
12432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12433 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12434 return SWIG_Py_Void();
12435 }
12436
12437 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12438 return SWIG_Python_InitShadowInstance(args);
12439 }
12440
12441 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12442 PyObject *resultobj = 0;
12443 wxImageHistogram *result = 0 ;
12444
12445 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (wxImageHistogram *)new wxImageHistogram();
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12460 PyObject *resultobj = 0;
12461 byte arg1 ;
12462 byte arg2 ;
12463 byte arg3 ;
12464 unsigned long result;
12465 unsigned char val1 ;
12466 int ecode1 = 0 ;
12467 unsigned char val2 ;
12468 int ecode2 = 0 ;
12469 unsigned char val3 ;
12470 int ecode3 = 0 ;
12471 PyObject * obj0 = 0 ;
12472 PyObject * obj1 = 0 ;
12473 PyObject * obj2 = 0 ;
12474 char * kwnames[] = {
12475 (char *) "r",(char *) "g",(char *) "b", NULL
12476 };
12477
12478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12479 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12480 if (!SWIG_IsOK(ecode1)) {
12481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12482 }
12483 arg1 = static_cast< byte >(val1);
12484 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12485 if (!SWIG_IsOK(ecode2)) {
12486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12487 }
12488 arg2 = static_cast< byte >(val2);
12489 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12490 if (!SWIG_IsOK(ecode3)) {
12491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12492 }
12493 arg3 = static_cast< byte >(val3);
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj = 0;
12509 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12510 byte *arg2 = (byte *) 0 ;
12511 byte *arg3 = (byte *) 0 ;
12512 byte *arg4 = (byte *) 0 ;
12513 byte arg5 = (byte) 1 ;
12514 byte arg6 = (byte) 0 ;
12515 byte arg7 = (byte) 0 ;
12516 bool result;
12517 void *argp1 = 0 ;
12518 int res1 = 0 ;
12519 byte temp2 ;
12520 int res2 = SWIG_TMPOBJ ;
12521 byte temp3 ;
12522 int res3 = SWIG_TMPOBJ ;
12523 byte temp4 ;
12524 int res4 = SWIG_TMPOBJ ;
12525 unsigned char val5 ;
12526 int ecode5 = 0 ;
12527 unsigned char val6 ;
12528 int ecode6 = 0 ;
12529 unsigned char val7 ;
12530 int ecode7 = 0 ;
12531 PyObject * obj0 = 0 ;
12532 PyObject * obj1 = 0 ;
12533 PyObject * obj2 = 0 ;
12534 PyObject * obj3 = 0 ;
12535 char * kwnames[] = {
12536 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12537 };
12538
12539 arg2 = &temp2;
12540 arg3 = &temp3;
12541 arg4 = &temp4;
12542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12544 if (!SWIG_IsOK(res1)) {
12545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12546 }
12547 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12548 if (obj1) {
12549 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12550 if (!SWIG_IsOK(ecode5)) {
12551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12552 }
12553 arg5 = static_cast< byte >(val5);
12554 }
12555 if (obj2) {
12556 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12557 if (!SWIG_IsOK(ecode6)) {
12558 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12559 }
12560 arg6 = static_cast< byte >(val6);
12561 }
12562 if (obj3) {
12563 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12564 if (!SWIG_IsOK(ecode7)) {
12565 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12566 }
12567 arg7 = static_cast< byte >(val7);
12568 }
12569 {
12570 PyThreadState* __tstate = wxPyBeginAllowThreads();
12571 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12572 wxPyEndAllowThreads(__tstate);
12573 if (PyErr_Occurred()) SWIG_fail;
12574 }
12575 {
12576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12577 }
12578 if (SWIG_IsTmpObj(res2)) {
12579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12580 } else {
12581 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12583 }
12584 if (SWIG_IsTmpObj(res3)) {
12585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12586 } else {
12587 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12589 }
12590 if (SWIG_IsTmpObj(res4)) {
12591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12592 } else {
12593 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12595 }
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12603 PyObject *resultobj = 0;
12604 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12605 unsigned long arg2 ;
12606 unsigned long result;
12607 void *argp1 = 0 ;
12608 int res1 = 0 ;
12609 unsigned long val2 ;
12610 int ecode2 = 0 ;
12611 PyObject * obj0 = 0 ;
12612 PyObject * obj1 = 0 ;
12613 char * kwnames[] = {
12614 (char *) "self",(char *) "key", NULL
12615 };
12616
12617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12619 if (!SWIG_IsOK(res1)) {
12620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12621 }
12622 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12623 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12624 if (!SWIG_IsOK(ecode2)) {
12625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12626 }
12627 arg2 = static_cast< unsigned long >(val2);
12628 {
12629 PyThreadState* __tstate = wxPyBeginAllowThreads();
12630 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12631 wxPyEndAllowThreads(__tstate);
12632 if (PyErr_Occurred()) SWIG_fail;
12633 }
12634 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12635 return resultobj;
12636 fail:
12637 return NULL;
12638 }
12639
12640
12641 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12642 PyObject *resultobj = 0;
12643 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12644 byte arg2 ;
12645 byte arg3 ;
12646 byte arg4 ;
12647 unsigned long result;
12648 void *argp1 = 0 ;
12649 int res1 = 0 ;
12650 unsigned char val2 ;
12651 int ecode2 = 0 ;
12652 unsigned char val3 ;
12653 int ecode3 = 0 ;
12654 unsigned char val4 ;
12655 int ecode4 = 0 ;
12656 PyObject * obj0 = 0 ;
12657 PyObject * obj1 = 0 ;
12658 PyObject * obj2 = 0 ;
12659 PyObject * obj3 = 0 ;
12660 char * kwnames[] = {
12661 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12662 };
12663
12664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12666 if (!SWIG_IsOK(res1)) {
12667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12668 }
12669 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12670 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12671 if (!SWIG_IsOK(ecode2)) {
12672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12673 }
12674 arg2 = static_cast< byte >(val2);
12675 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12676 if (!SWIG_IsOK(ecode3)) {
12677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12678 }
12679 arg3 = static_cast< byte >(val3);
12680 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12681 if (!SWIG_IsOK(ecode4)) {
12682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12683 }
12684 arg4 = static_cast< byte >(val4);
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj = 0;
12700 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12701 wxColour *arg2 = 0 ;
12702 unsigned long result;
12703 void *argp1 = 0 ;
12704 int res1 = 0 ;
12705 wxColour temp2 ;
12706 PyObject * obj0 = 0 ;
12707 PyObject * obj1 = 0 ;
12708 char * kwnames[] = {
12709 (char *) "self",(char *) "colour", NULL
12710 };
12711
12712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12714 if (!SWIG_IsOK(res1)) {
12715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12716 }
12717 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12718 {
12719 arg2 = &temp2;
12720 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12721 }
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12736 PyObject *obj;
12737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12738 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12739 return SWIG_Py_Void();
12740 }
12741
12742 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12743 return SWIG_Python_InitShadowInstance(args);
12744 }
12745
12746 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12747 PyObject *resultobj = 0;
12748 byte arg1 = (byte) 0 ;
12749 byte arg2 = (byte) 0 ;
12750 byte arg3 = (byte) 0 ;
12751 wxImage_RGBValue *result = 0 ;
12752 unsigned char val1 ;
12753 int ecode1 = 0 ;
12754 unsigned char val2 ;
12755 int ecode2 = 0 ;
12756 unsigned char val3 ;
12757 int ecode3 = 0 ;
12758 PyObject * obj0 = 0 ;
12759 PyObject * obj1 = 0 ;
12760 PyObject * obj2 = 0 ;
12761 char * kwnames[] = {
12762 (char *) "r",(char *) "g",(char *) "b", NULL
12763 };
12764
12765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12766 if (obj0) {
12767 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12768 if (!SWIG_IsOK(ecode1)) {
12769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12770 }
12771 arg1 = static_cast< byte >(val1);
12772 }
12773 if (obj1) {
12774 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12775 if (!SWIG_IsOK(ecode2)) {
12776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12777 }
12778 arg2 = static_cast< byte >(val2);
12779 }
12780 if (obj2) {
12781 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12782 if (!SWIG_IsOK(ecode3)) {
12783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12784 }
12785 arg3 = static_cast< byte >(val3);
12786 }
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12794 return resultobj;
12795 fail:
12796 return NULL;
12797 }
12798
12799
12800 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12801 PyObject *resultobj = 0;
12802 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12803 byte arg2 ;
12804 void *argp1 = 0 ;
12805 int res1 = 0 ;
12806 unsigned char val2 ;
12807 int ecode2 = 0 ;
12808 PyObject *swig_obj[2] ;
12809
12810 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12812 if (!SWIG_IsOK(res1)) {
12813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12814 }
12815 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12816 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12817 if (!SWIG_IsOK(ecode2)) {
12818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12819 }
12820 arg2 = static_cast< byte >(val2);
12821 if (arg1) (arg1)->red = arg2;
12822
12823 resultobj = SWIG_Py_Void();
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12831 PyObject *resultobj = 0;
12832 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12833 byte result;
12834 void *argp1 = 0 ;
12835 int res1 = 0 ;
12836 PyObject *swig_obj[1] ;
12837
12838 if (!args) SWIG_fail;
12839 swig_obj[0] = args;
12840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12841 if (!SWIG_IsOK(res1)) {
12842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12843 }
12844 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12845 result = (byte) ((arg1)->red);
12846 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12847 return resultobj;
12848 fail:
12849 return NULL;
12850 }
12851
12852
12853 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12854 PyObject *resultobj = 0;
12855 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12856 byte arg2 ;
12857 void *argp1 = 0 ;
12858 int res1 = 0 ;
12859 unsigned char val2 ;
12860 int ecode2 = 0 ;
12861 PyObject *swig_obj[2] ;
12862
12863 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12865 if (!SWIG_IsOK(res1)) {
12866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12867 }
12868 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12869 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12870 if (!SWIG_IsOK(ecode2)) {
12871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12872 }
12873 arg2 = static_cast< byte >(val2);
12874 if (arg1) (arg1)->green = arg2;
12875
12876 resultobj = SWIG_Py_Void();
12877 return resultobj;
12878 fail:
12879 return NULL;
12880 }
12881
12882
12883 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12884 PyObject *resultobj = 0;
12885 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12886 byte result;
12887 void *argp1 = 0 ;
12888 int res1 = 0 ;
12889 PyObject *swig_obj[1] ;
12890
12891 if (!args) SWIG_fail;
12892 swig_obj[0] = args;
12893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12894 if (!SWIG_IsOK(res1)) {
12895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12896 }
12897 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12898 result = (byte) ((arg1)->green);
12899 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12900 return resultobj;
12901 fail:
12902 return NULL;
12903 }
12904
12905
12906 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12907 PyObject *resultobj = 0;
12908 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12909 byte arg2 ;
12910 void *argp1 = 0 ;
12911 int res1 = 0 ;
12912 unsigned char val2 ;
12913 int ecode2 = 0 ;
12914 PyObject *swig_obj[2] ;
12915
12916 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12918 if (!SWIG_IsOK(res1)) {
12919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12920 }
12921 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12922 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12923 if (!SWIG_IsOK(ecode2)) {
12924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12925 }
12926 arg2 = static_cast< byte >(val2);
12927 if (arg1) (arg1)->blue = arg2;
12928
12929 resultobj = SWIG_Py_Void();
12930 return resultobj;
12931 fail:
12932 return NULL;
12933 }
12934
12935
12936 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12937 PyObject *resultobj = 0;
12938 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12939 byte result;
12940 void *argp1 = 0 ;
12941 int res1 = 0 ;
12942 PyObject *swig_obj[1] ;
12943
12944 if (!args) SWIG_fail;
12945 swig_obj[0] = args;
12946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12947 if (!SWIG_IsOK(res1)) {
12948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12949 }
12950 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12951 result = (byte) ((arg1)->blue);
12952 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12960 PyObject *obj;
12961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12962 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12963 return SWIG_Py_Void();
12964 }
12965
12966 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 return SWIG_Python_InitShadowInstance(args);
12968 }
12969
12970 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12971 PyObject *resultobj = 0;
12972 double arg1 = (double) 0.0 ;
12973 double arg2 = (double) 0.0 ;
12974 double arg3 = (double) 0.0 ;
12975 wxImage_HSVValue *result = 0 ;
12976 double val1 ;
12977 int ecode1 = 0 ;
12978 double val2 ;
12979 int ecode2 = 0 ;
12980 double val3 ;
12981 int ecode3 = 0 ;
12982 PyObject * obj0 = 0 ;
12983 PyObject * obj1 = 0 ;
12984 PyObject * obj2 = 0 ;
12985 char * kwnames[] = {
12986 (char *) "h",(char *) "s",(char *) "v", NULL
12987 };
12988
12989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12990 if (obj0) {
12991 ecode1 = SWIG_AsVal_double(obj0, &val1);
12992 if (!SWIG_IsOK(ecode1)) {
12993 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12994 }
12995 arg1 = static_cast< double >(val1);
12996 }
12997 if (obj1) {
12998 ecode2 = SWIG_AsVal_double(obj1, &val2);
12999 if (!SWIG_IsOK(ecode2)) {
13000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13001 }
13002 arg2 = static_cast< double >(val2);
13003 }
13004 if (obj2) {
13005 ecode3 = SWIG_AsVal_double(obj2, &val3);
13006 if (!SWIG_IsOK(ecode3)) {
13007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13008 }
13009 arg3 = static_cast< double >(val3);
13010 }
13011 {
13012 PyThreadState* __tstate = wxPyBeginAllowThreads();
13013 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13014 wxPyEndAllowThreads(__tstate);
13015 if (PyErr_Occurred()) SWIG_fail;
13016 }
13017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13018 return resultobj;
13019 fail:
13020 return NULL;
13021 }
13022
13023
13024 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13025 PyObject *resultobj = 0;
13026 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13027 double arg2 ;
13028 void *argp1 = 0 ;
13029 int res1 = 0 ;
13030 double val2 ;
13031 int ecode2 = 0 ;
13032 PyObject *swig_obj[2] ;
13033
13034 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13036 if (!SWIG_IsOK(res1)) {
13037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13038 }
13039 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13040 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13041 if (!SWIG_IsOK(ecode2)) {
13042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13043 }
13044 arg2 = static_cast< double >(val2);
13045 if (arg1) (arg1)->hue = arg2;
13046
13047 resultobj = SWIG_Py_Void();
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13055 PyObject *resultobj = 0;
13056 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13057 double result;
13058 void *argp1 = 0 ;
13059 int res1 = 0 ;
13060 PyObject *swig_obj[1] ;
13061
13062 if (!args) SWIG_fail;
13063 swig_obj[0] = args;
13064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13065 if (!SWIG_IsOK(res1)) {
13066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13067 }
13068 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13069 result = (double) ((arg1)->hue);
13070 resultobj = SWIG_From_double(static_cast< double >(result));
13071 return resultobj;
13072 fail:
13073 return NULL;
13074 }
13075
13076
13077 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13078 PyObject *resultobj = 0;
13079 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13080 double arg2 ;
13081 void *argp1 = 0 ;
13082 int res1 = 0 ;
13083 double val2 ;
13084 int ecode2 = 0 ;
13085 PyObject *swig_obj[2] ;
13086
13087 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13089 if (!SWIG_IsOK(res1)) {
13090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13091 }
13092 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13093 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13094 if (!SWIG_IsOK(ecode2)) {
13095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13096 }
13097 arg2 = static_cast< double >(val2);
13098 if (arg1) (arg1)->saturation = arg2;
13099
13100 resultobj = SWIG_Py_Void();
13101 return resultobj;
13102 fail:
13103 return NULL;
13104 }
13105
13106
13107 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13108 PyObject *resultobj = 0;
13109 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13110 double result;
13111 void *argp1 = 0 ;
13112 int res1 = 0 ;
13113 PyObject *swig_obj[1] ;
13114
13115 if (!args) SWIG_fail;
13116 swig_obj[0] = args;
13117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13118 if (!SWIG_IsOK(res1)) {
13119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13120 }
13121 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13122 result = (double) ((arg1)->saturation);
13123 resultobj = SWIG_From_double(static_cast< double >(result));
13124 return resultobj;
13125 fail:
13126 return NULL;
13127 }
13128
13129
13130 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13131 PyObject *resultobj = 0;
13132 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13133 double arg2 ;
13134 void *argp1 = 0 ;
13135 int res1 = 0 ;
13136 double val2 ;
13137 int ecode2 = 0 ;
13138 PyObject *swig_obj[2] ;
13139
13140 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13142 if (!SWIG_IsOK(res1)) {
13143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13144 }
13145 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13146 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13147 if (!SWIG_IsOK(ecode2)) {
13148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13149 }
13150 arg2 = static_cast< double >(val2);
13151 if (arg1) (arg1)->value = arg2;
13152
13153 resultobj = SWIG_Py_Void();
13154 return resultobj;
13155 fail:
13156 return NULL;
13157 }
13158
13159
13160 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13161 PyObject *resultobj = 0;
13162 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13163 double result;
13164 void *argp1 = 0 ;
13165 int res1 = 0 ;
13166 PyObject *swig_obj[1] ;
13167
13168 if (!args) SWIG_fail;
13169 swig_obj[0] = args;
13170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13171 if (!SWIG_IsOK(res1)) {
13172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13173 }
13174 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13175 result = (double) ((arg1)->value);
13176 resultobj = SWIG_From_double(static_cast< double >(result));
13177 return resultobj;
13178 fail:
13179 return NULL;
13180 }
13181
13182
13183 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13184 PyObject *obj;
13185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13186 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13187 return SWIG_Py_Void();
13188 }
13189
13190 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13191 return SWIG_Python_InitShadowInstance(args);
13192 }
13193
13194 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13195 PyObject *resultobj = 0;
13196 wxString *arg1 = 0 ;
13197 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13198 int arg3 = (int) -1 ;
13199 wxImage *result = 0 ;
13200 bool temp1 = false ;
13201 long val2 ;
13202 int ecode2 = 0 ;
13203 int val3 ;
13204 int ecode3 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 PyObject * obj1 = 0 ;
13207 PyObject * obj2 = 0 ;
13208 char * kwnames[] = {
13209 (char *) "name",(char *) "type",(char *) "index", NULL
13210 };
13211
13212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13213 {
13214 arg1 = wxString_in_helper(obj0);
13215 if (arg1 == NULL) SWIG_fail;
13216 temp1 = true;
13217 }
13218 if (obj1) {
13219 ecode2 = SWIG_AsVal_long(obj1, &val2);
13220 if (!SWIG_IsOK(ecode2)) {
13221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13222 }
13223 arg2 = static_cast< long >(val2);
13224 }
13225 if (obj2) {
13226 ecode3 = SWIG_AsVal_int(obj2, &val3);
13227 if (!SWIG_IsOK(ecode3)) {
13228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13229 }
13230 arg3 = static_cast< int >(val3);
13231 }
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13239 {
13240 if (temp1)
13241 delete arg1;
13242 }
13243 return resultobj;
13244 fail:
13245 {
13246 if (temp1)
13247 delete arg1;
13248 }
13249 return NULL;
13250 }
13251
13252
13253 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13254 PyObject *resultobj = 0;
13255 wxImage *arg1 = (wxImage *) 0 ;
13256 void *argp1 = 0 ;
13257 int res1 = 0 ;
13258 PyObject *swig_obj[1] ;
13259
13260 if (!args) SWIG_fail;
13261 swig_obj[0] = args;
13262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13263 if (!SWIG_IsOK(res1)) {
13264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13265 }
13266 arg1 = reinterpret_cast< wxImage * >(argp1);
13267 {
13268 PyThreadState* __tstate = wxPyBeginAllowThreads();
13269 delete arg1;
13270
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 resultobj = SWIG_Py_Void();
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj = 0;
13283 wxString *arg1 = 0 ;
13284 wxString *arg2 = 0 ;
13285 int arg3 = (int) -1 ;
13286 wxImage *result = 0 ;
13287 bool temp1 = false ;
13288 bool temp2 = false ;
13289 int val3 ;
13290 int ecode3 = 0 ;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 PyObject * obj2 = 0 ;
13294 char * kwnames[] = {
13295 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13296 };
13297
13298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13299 {
13300 arg1 = wxString_in_helper(obj0);
13301 if (arg1 == NULL) SWIG_fail;
13302 temp1 = true;
13303 }
13304 {
13305 arg2 = wxString_in_helper(obj1);
13306 if (arg2 == NULL) SWIG_fail;
13307 temp2 = true;
13308 }
13309 if (obj2) {
13310 ecode3 = SWIG_AsVal_int(obj2, &val3);
13311 if (!SWIG_IsOK(ecode3)) {
13312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13313 }
13314 arg3 = static_cast< int >(val3);
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13323 {
13324 if (temp1)
13325 delete arg1;
13326 }
13327 {
13328 if (temp2)
13329 delete arg2;
13330 }
13331 return resultobj;
13332 fail:
13333 {
13334 if (temp1)
13335 delete arg1;
13336 }
13337 {
13338 if (temp2)
13339 delete arg2;
13340 }
13341 return NULL;
13342 }
13343
13344
13345 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13346 PyObject *resultobj = 0;
13347 wxInputStream *arg1 = 0 ;
13348 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13349 int arg3 = (int) -1 ;
13350 wxImage *result = 0 ;
13351 wxPyInputStream *temp1 ;
13352 bool created1 ;
13353 long val2 ;
13354 int ecode2 = 0 ;
13355 int val3 ;
13356 int ecode3 = 0 ;
13357 PyObject * obj0 = 0 ;
13358 PyObject * obj1 = 0 ;
13359 PyObject * obj2 = 0 ;
13360 char * kwnames[] = {
13361 (char *) "stream",(char *) "type",(char *) "index", NULL
13362 };
13363
13364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13365 {
13366 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13367 arg1 = temp1->m_wxis;
13368 created1 = false;
13369 } else {
13370 PyErr_Clear(); // clear the failure of the wxPyConvert above
13371 arg1 = wxPyCBInputStream_create(obj0, false);
13372 if (arg1 == NULL) {
13373 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13374 SWIG_fail;
13375 }
13376 created1 = true;
13377 }
13378 }
13379 if (obj1) {
13380 ecode2 = SWIG_AsVal_long(obj1, &val2);
13381 if (!SWIG_IsOK(ecode2)) {
13382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13383 }
13384 arg2 = static_cast< long >(val2);
13385 }
13386 if (obj2) {
13387 ecode3 = SWIG_AsVal_int(obj2, &val3);
13388 if (!SWIG_IsOK(ecode3)) {
13389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13390 }
13391 arg3 = static_cast< int >(val3);
13392 }
13393 {
13394 PyThreadState* __tstate = wxPyBeginAllowThreads();
13395 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13400 {
13401 if (created1) delete arg1;
13402 }
13403 return resultobj;
13404 fail:
13405 {
13406 if (created1) delete arg1;
13407 }
13408 return NULL;
13409 }
13410
13411
13412 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj = 0;
13414 wxInputStream *arg1 = 0 ;
13415 wxString *arg2 = 0 ;
13416 int arg3 = (int) -1 ;
13417 wxImage *result = 0 ;
13418 wxPyInputStream *temp1 ;
13419 bool created1 ;
13420 bool temp2 = false ;
13421 int val3 ;
13422 int ecode3 = 0 ;
13423 PyObject * obj0 = 0 ;
13424 PyObject * obj1 = 0 ;
13425 PyObject * obj2 = 0 ;
13426 char * kwnames[] = {
13427 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13428 };
13429
13430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13431 {
13432 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13433 arg1 = temp1->m_wxis;
13434 created1 = false;
13435 } else {
13436 PyErr_Clear(); // clear the failure of the wxPyConvert above
13437 arg1 = wxPyCBInputStream_create(obj0, false);
13438 if (arg1 == NULL) {
13439 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13440 SWIG_fail;
13441 }
13442 created1 = true;
13443 }
13444 }
13445 {
13446 arg2 = wxString_in_helper(obj1);
13447 if (arg2 == NULL) SWIG_fail;
13448 temp2 = true;
13449 }
13450 if (obj2) {
13451 ecode3 = SWIG_AsVal_int(obj2, &val3);
13452 if (!SWIG_IsOK(ecode3)) {
13453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13454 }
13455 arg3 = static_cast< int >(val3);
13456 }
13457 {
13458 PyThreadState* __tstate = wxPyBeginAllowThreads();
13459 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13460 wxPyEndAllowThreads(__tstate);
13461 if (PyErr_Occurred()) SWIG_fail;
13462 }
13463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13464 {
13465 if (created1) delete arg1;
13466 }
13467 {
13468 if (temp2)
13469 delete arg2;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (created1) delete arg1;
13475 }
13476 {
13477 if (temp2)
13478 delete arg2;
13479 }
13480 return NULL;
13481 }
13482
13483
13484 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13485 PyObject *resultobj = 0;
13486 int arg1 = (int) 0 ;
13487 int arg2 = (int) 0 ;
13488 bool arg3 = (bool) true ;
13489 wxImage *result = 0 ;
13490 int val1 ;
13491 int ecode1 = 0 ;
13492 int val2 ;
13493 int ecode2 = 0 ;
13494 bool val3 ;
13495 int ecode3 = 0 ;
13496 PyObject * obj0 = 0 ;
13497 PyObject * obj1 = 0 ;
13498 PyObject * obj2 = 0 ;
13499 char * kwnames[] = {
13500 (char *) "width",(char *) "height",(char *) "clear", NULL
13501 };
13502
13503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13504 if (obj0) {
13505 ecode1 = SWIG_AsVal_int(obj0, &val1);
13506 if (!SWIG_IsOK(ecode1)) {
13507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13508 }
13509 arg1 = static_cast< int >(val1);
13510 }
13511 if (obj1) {
13512 ecode2 = SWIG_AsVal_int(obj1, &val2);
13513 if (!SWIG_IsOK(ecode2)) {
13514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13515 }
13516 arg2 = static_cast< int >(val2);
13517 }
13518 if (obj2) {
13519 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13520 if (!SWIG_IsOK(ecode3)) {
13521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13522 }
13523 arg3 = static_cast< bool >(val3);
13524 }
13525 {
13526 PyThreadState* __tstate = wxPyBeginAllowThreads();
13527 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13528 wxPyEndAllowThreads(__tstate);
13529 if (PyErr_Occurred()) SWIG_fail;
13530 }
13531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13532 return resultobj;
13533 fail:
13534 return NULL;
13535 }
13536
13537
13538 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13539 PyObject *resultobj = 0;
13540 wxBitmap *arg1 = 0 ;
13541 wxImage *result = 0 ;
13542 void *argp1 = 0 ;
13543 int res1 = 0 ;
13544 PyObject * obj0 = 0 ;
13545 char * kwnames[] = {
13546 (char *) "bitmap", NULL
13547 };
13548
13549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13550 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13551 if (!SWIG_IsOK(res1)) {
13552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13553 }
13554 if (!argp1) {
13555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13556 }
13557 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13558 {
13559 if (!wxPyCheckForApp()) SWIG_fail;
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13562 wxPyEndAllowThreads(__tstate);
13563 if (PyErr_Occurred()) SWIG_fail;
13564 }
13565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13566 return resultobj;
13567 fail:
13568 return NULL;
13569 }
13570
13571
13572 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13573 PyObject *resultobj = 0;
13574 int arg1 ;
13575 int arg2 ;
13576 buffer arg3 ;
13577 int arg4 ;
13578 wxImage *result = 0 ;
13579 int val1 ;
13580 int ecode1 = 0 ;
13581 int val2 ;
13582 int ecode2 = 0 ;
13583 Py_ssize_t temp3 ;
13584 PyObject * obj0 = 0 ;
13585 PyObject * obj1 = 0 ;
13586 PyObject * obj2 = 0 ;
13587 char * kwnames[] = {
13588 (char *) "width",(char *) "height",(char *) "data", NULL
13589 };
13590
13591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13592 ecode1 = SWIG_AsVal_int(obj0, &val1);
13593 if (!SWIG_IsOK(ecode1)) {
13594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13595 }
13596 arg1 = static_cast< int >(val1);
13597 ecode2 = SWIG_AsVal_int(obj1, &val2);
13598 if (!SWIG_IsOK(ecode2)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13600 }
13601 arg2 = static_cast< int >(val2);
13602 {
13603 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13604 arg4 = (int)temp3;
13605 }
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = 0;
13621 int arg1 ;
13622 int arg2 ;
13623 buffer arg3 ;
13624 int arg4 ;
13625 buffer arg5 ;
13626 int arg6 ;
13627 wxImage *result = 0 ;
13628 int val1 ;
13629 int ecode1 = 0 ;
13630 int val2 ;
13631 int ecode2 = 0 ;
13632 Py_ssize_t temp3 ;
13633 Py_ssize_t temp5 ;
13634 PyObject * obj0 = 0 ;
13635 PyObject * obj1 = 0 ;
13636 PyObject * obj2 = 0 ;
13637 PyObject * obj3 = 0 ;
13638 char * kwnames[] = {
13639 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13640 };
13641
13642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13643 ecode1 = SWIG_AsVal_int(obj0, &val1);
13644 if (!SWIG_IsOK(ecode1)) {
13645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13646 }
13647 arg1 = static_cast< int >(val1);
13648 ecode2 = SWIG_AsVal_int(obj1, &val2);
13649 if (!SWIG_IsOK(ecode2)) {
13650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13651 }
13652 arg2 = static_cast< int >(val2);
13653 {
13654 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13655 arg4 = (int)temp3;
13656 }
13657 {
13658 if (obj3 != Py_None) {
13659 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13660 arg6 = (int)temp5;
13661 }
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13670 return resultobj;
13671 fail:
13672 return NULL;
13673 }
13674
13675
13676 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13677 PyObject *resultobj = 0;
13678 wxImage *arg1 = (wxImage *) 0 ;
13679 int arg2 ;
13680 int arg3 ;
13681 bool arg4 = (bool) true ;
13682 void *argp1 = 0 ;
13683 int res1 = 0 ;
13684 int val2 ;
13685 int ecode2 = 0 ;
13686 int val3 ;
13687 int ecode3 = 0 ;
13688 bool val4 ;
13689 int ecode4 = 0 ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 PyObject * obj2 = 0 ;
13693 PyObject * obj3 = 0 ;
13694 char * kwnames[] = {
13695 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13696 };
13697
13698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13700 if (!SWIG_IsOK(res1)) {
13701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13702 }
13703 arg1 = reinterpret_cast< wxImage * >(argp1);
13704 ecode2 = SWIG_AsVal_int(obj1, &val2);
13705 if (!SWIG_IsOK(ecode2)) {
13706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13707 }
13708 arg2 = static_cast< int >(val2);
13709 ecode3 = SWIG_AsVal_int(obj2, &val3);
13710 if (!SWIG_IsOK(ecode3)) {
13711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13712 }
13713 arg3 = static_cast< int >(val3);
13714 if (obj3) {
13715 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13716 if (!SWIG_IsOK(ecode4)) {
13717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13718 }
13719 arg4 = static_cast< bool >(val4);
13720 }
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 (arg1)->Create(arg2,arg3,arg4);
13724 wxPyEndAllowThreads(__tstate);
13725 if (PyErr_Occurred()) SWIG_fail;
13726 }
13727 resultobj = SWIG_Py_Void();
13728 return resultobj;
13729 fail:
13730 return NULL;
13731 }
13732
13733
13734 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13735 PyObject *resultobj = 0;
13736 wxImage *arg1 = (wxImage *) 0 ;
13737 void *argp1 = 0 ;
13738 int res1 = 0 ;
13739 PyObject *swig_obj[1] ;
13740
13741 if (!args) SWIG_fail;
13742 swig_obj[0] = args;
13743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13744 if (!SWIG_IsOK(res1)) {
13745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13746 }
13747 arg1 = reinterpret_cast< wxImage * >(argp1);
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 (arg1)->Destroy();
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 resultobj = SWIG_Py_Void();
13755 return resultobj;
13756 fail:
13757 return NULL;
13758 }
13759
13760
13761 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13762 PyObject *resultobj = 0;
13763 wxImage *arg1 = (wxImage *) 0 ;
13764 int arg2 ;
13765 int arg3 ;
13766 SwigValueWrapper<wxImage > result;
13767 void *argp1 = 0 ;
13768 int res1 = 0 ;
13769 int val2 ;
13770 int ecode2 = 0 ;
13771 int val3 ;
13772 int ecode3 = 0 ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 char * kwnames[] = {
13777 (char *) "self",(char *) "width",(char *) "height", NULL
13778 };
13779
13780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13782 if (!SWIG_IsOK(res1)) {
13783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13784 }
13785 arg1 = reinterpret_cast< wxImage * >(argp1);
13786 ecode2 = SWIG_AsVal_int(obj1, &val2);
13787 if (!SWIG_IsOK(ecode2)) {
13788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13789 }
13790 arg2 = static_cast< int >(val2);
13791 ecode3 = SWIG_AsVal_int(obj2, &val3);
13792 if (!SWIG_IsOK(ecode3)) {
13793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13794 }
13795 arg3 = static_cast< int >(val3);
13796 {
13797 PyThreadState* __tstate = wxPyBeginAllowThreads();
13798 result = (arg1)->Scale(arg2,arg3);
13799 wxPyEndAllowThreads(__tstate);
13800 if (PyErr_Occurred()) SWIG_fail;
13801 }
13802 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj = 0;
13811 wxImage *arg1 = (wxImage *) 0 ;
13812 int arg2 ;
13813 int arg3 ;
13814 SwigValueWrapper<wxImage > result;
13815 void *argp1 = 0 ;
13816 int res1 = 0 ;
13817 int val2 ;
13818 int ecode2 = 0 ;
13819 int val3 ;
13820 int ecode3 = 0 ;
13821 PyObject * obj0 = 0 ;
13822 PyObject * obj1 = 0 ;
13823 PyObject * obj2 = 0 ;
13824 char * kwnames[] = {
13825 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13826 };
13827
13828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13830 if (!SWIG_IsOK(res1)) {
13831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13832 }
13833 arg1 = reinterpret_cast< wxImage * >(argp1);
13834 ecode2 = SWIG_AsVal_int(obj1, &val2);
13835 if (!SWIG_IsOK(ecode2)) {
13836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13837 }
13838 arg2 = static_cast< int >(val2);
13839 ecode3 = SWIG_AsVal_int(obj2, &val3);
13840 if (!SWIG_IsOK(ecode3)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13842 }
13843 arg3 = static_cast< int >(val3);
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13847 wxPyEndAllowThreads(__tstate);
13848 if (PyErr_Occurred()) SWIG_fail;
13849 }
13850 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13851 return resultobj;
13852 fail:
13853 return NULL;
13854 }
13855
13856
13857 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13858 PyObject *resultobj = 0;
13859 wxImage *arg1 = (wxImage *) 0 ;
13860 int arg2 ;
13861 int arg3 ;
13862 wxImage *result = 0 ;
13863 void *argp1 = 0 ;
13864 int res1 = 0 ;
13865 int val2 ;
13866 int ecode2 = 0 ;
13867 int val3 ;
13868 int ecode3 = 0 ;
13869 PyObject * obj0 = 0 ;
13870 PyObject * obj1 = 0 ;
13871 PyObject * obj2 = 0 ;
13872 char * kwnames[] = {
13873 (char *) "self",(char *) "width",(char *) "height", NULL
13874 };
13875
13876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13878 if (!SWIG_IsOK(res1)) {
13879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13880 }
13881 arg1 = reinterpret_cast< wxImage * >(argp1);
13882 ecode2 = SWIG_AsVal_int(obj1, &val2);
13883 if (!SWIG_IsOK(ecode2)) {
13884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13885 }
13886 arg2 = static_cast< int >(val2);
13887 ecode3 = SWIG_AsVal_int(obj2, &val3);
13888 if (!SWIG_IsOK(ecode3)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13890 }
13891 arg3 = static_cast< int >(val3);
13892 {
13893 PyThreadState* __tstate = wxPyBeginAllowThreads();
13894 {
13895 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13896 result = (wxImage *) &_result_ref;
13897 }
13898 wxPyEndAllowThreads(__tstate);
13899 if (PyErr_Occurred()) SWIG_fail;
13900 }
13901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13902 return resultobj;
13903 fail:
13904 return NULL;
13905 }
13906
13907
13908 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13909 PyObject *resultobj = 0;
13910 wxImage *arg1 = (wxImage *) 0 ;
13911 wxSize *arg2 = 0 ;
13912 wxPoint *arg3 = 0 ;
13913 int arg4 = (int) -1 ;
13914 int arg5 = (int) -1 ;
13915 int arg6 = (int) -1 ;
13916 wxImage *result = 0 ;
13917 void *argp1 = 0 ;
13918 int res1 = 0 ;
13919 wxSize temp2 ;
13920 wxPoint temp3 ;
13921 int val4 ;
13922 int ecode4 = 0 ;
13923 int val5 ;
13924 int ecode5 = 0 ;
13925 int val6 ;
13926 int ecode6 = 0 ;
13927 PyObject * obj0 = 0 ;
13928 PyObject * obj1 = 0 ;
13929 PyObject * obj2 = 0 ;
13930 PyObject * obj3 = 0 ;
13931 PyObject * obj4 = 0 ;
13932 PyObject * obj5 = 0 ;
13933 char * kwnames[] = {
13934 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13935 };
13936
13937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13939 if (!SWIG_IsOK(res1)) {
13940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13941 }
13942 arg1 = reinterpret_cast< wxImage * >(argp1);
13943 {
13944 arg2 = &temp2;
13945 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13946 }
13947 {
13948 arg3 = &temp3;
13949 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13950 }
13951 if (obj3) {
13952 ecode4 = SWIG_AsVal_int(obj3, &val4);
13953 if (!SWIG_IsOK(ecode4)) {
13954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13955 }
13956 arg4 = static_cast< int >(val4);
13957 }
13958 if (obj4) {
13959 ecode5 = SWIG_AsVal_int(obj4, &val5);
13960 if (!SWIG_IsOK(ecode5)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13962 }
13963 arg5 = static_cast< int >(val5);
13964 }
13965 if (obj5) {
13966 ecode6 = SWIG_AsVal_int(obj5, &val6);
13967 if (!SWIG_IsOK(ecode6)) {
13968 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13969 }
13970 arg6 = static_cast< int >(val6);
13971 }
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 {
13975 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13976 result = (wxImage *) &_result_ref;
13977 }
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13989 PyObject *resultobj = 0;
13990 wxImage *arg1 = (wxImage *) 0 ;
13991 int arg2 ;
13992 int arg3 ;
13993 byte arg4 ;
13994 byte arg5 ;
13995 byte arg6 ;
13996 void *argp1 = 0 ;
13997 int res1 = 0 ;
13998 int val2 ;
13999 int ecode2 = 0 ;
14000 int val3 ;
14001 int ecode3 = 0 ;
14002 unsigned char val4 ;
14003 int ecode4 = 0 ;
14004 unsigned char val5 ;
14005 int ecode5 = 0 ;
14006 unsigned char val6 ;
14007 int ecode6 = 0 ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 PyObject * obj2 = 0 ;
14011 PyObject * obj3 = 0 ;
14012 PyObject * obj4 = 0 ;
14013 PyObject * obj5 = 0 ;
14014 char * kwnames[] = {
14015 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14016 };
14017
14018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14020 if (!SWIG_IsOK(res1)) {
14021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14022 }
14023 arg1 = reinterpret_cast< wxImage * >(argp1);
14024 ecode2 = SWIG_AsVal_int(obj1, &val2);
14025 if (!SWIG_IsOK(ecode2)) {
14026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14027 }
14028 arg2 = static_cast< int >(val2);
14029 ecode3 = SWIG_AsVal_int(obj2, &val3);
14030 if (!SWIG_IsOK(ecode3)) {
14031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14032 }
14033 arg3 = static_cast< int >(val3);
14034 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14035 if (!SWIG_IsOK(ecode4)) {
14036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14037 }
14038 arg4 = static_cast< byte >(val4);
14039 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14040 if (!SWIG_IsOK(ecode5)) {
14041 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14042 }
14043 arg5 = static_cast< byte >(val5);
14044 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14045 if (!SWIG_IsOK(ecode6)) {
14046 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14047 }
14048 arg6 = static_cast< byte >(val6);
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 resultobj = SWIG_Py_Void();
14056 return resultobj;
14057 fail:
14058 return NULL;
14059 }
14060
14061
14062 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14063 PyObject *resultobj = 0;
14064 wxImage *arg1 = (wxImage *) 0 ;
14065 wxRect *arg2 = 0 ;
14066 byte arg3 ;
14067 byte arg4 ;
14068 byte arg5 ;
14069 void *argp1 = 0 ;
14070 int res1 = 0 ;
14071 wxRect temp2 ;
14072 unsigned char val3 ;
14073 int ecode3 = 0 ;
14074 unsigned char val4 ;
14075 int ecode4 = 0 ;
14076 unsigned char val5 ;
14077 int ecode5 = 0 ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 PyObject * obj2 = 0 ;
14081 PyObject * obj3 = 0 ;
14082 PyObject * obj4 = 0 ;
14083 char * kwnames[] = {
14084 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14085 };
14086
14087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14089 if (!SWIG_IsOK(res1)) {
14090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14091 }
14092 arg1 = reinterpret_cast< wxImage * >(argp1);
14093 {
14094 arg2 = &temp2;
14095 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14096 }
14097 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14098 if (!SWIG_IsOK(ecode3)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14100 }
14101 arg3 = static_cast< byte >(val3);
14102 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14103 if (!SWIG_IsOK(ecode4)) {
14104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14105 }
14106 arg4 = static_cast< byte >(val4);
14107 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14108 if (!SWIG_IsOK(ecode5)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14110 }
14111 arg5 = static_cast< byte >(val5);
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 resultobj = SWIG_Py_Void();
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj = 0;
14127 wxImage *arg1 = (wxImage *) 0 ;
14128 int arg2 ;
14129 int arg3 ;
14130 byte result;
14131 void *argp1 = 0 ;
14132 int res1 = 0 ;
14133 int val2 ;
14134 int ecode2 = 0 ;
14135 int val3 ;
14136 int ecode3 = 0 ;
14137 PyObject * obj0 = 0 ;
14138 PyObject * obj1 = 0 ;
14139 PyObject * obj2 = 0 ;
14140 char * kwnames[] = {
14141 (char *) "self",(char *) "x",(char *) "y", NULL
14142 };
14143
14144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14146 if (!SWIG_IsOK(res1)) {
14147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14148 }
14149 arg1 = reinterpret_cast< wxImage * >(argp1);
14150 ecode2 = SWIG_AsVal_int(obj1, &val2);
14151 if (!SWIG_IsOK(ecode2)) {
14152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14153 }
14154 arg2 = static_cast< int >(val2);
14155 ecode3 = SWIG_AsVal_int(obj2, &val3);
14156 if (!SWIG_IsOK(ecode3)) {
14157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14158 }
14159 arg3 = static_cast< int >(val3);
14160 {
14161 PyThreadState* __tstate = wxPyBeginAllowThreads();
14162 result = (byte)(arg1)->GetRed(arg2,arg3);
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14167 return resultobj;
14168 fail:
14169 return NULL;
14170 }
14171
14172
14173 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14174 PyObject *resultobj = 0;
14175 wxImage *arg1 = (wxImage *) 0 ;
14176 int arg2 ;
14177 int arg3 ;
14178 byte result;
14179 void *argp1 = 0 ;
14180 int res1 = 0 ;
14181 int val2 ;
14182 int ecode2 = 0 ;
14183 int val3 ;
14184 int ecode3 = 0 ;
14185 PyObject * obj0 = 0 ;
14186 PyObject * obj1 = 0 ;
14187 PyObject * obj2 = 0 ;
14188 char * kwnames[] = {
14189 (char *) "self",(char *) "x",(char *) "y", NULL
14190 };
14191
14192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14194 if (!SWIG_IsOK(res1)) {
14195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14196 }
14197 arg1 = reinterpret_cast< wxImage * >(argp1);
14198 ecode2 = SWIG_AsVal_int(obj1, &val2);
14199 if (!SWIG_IsOK(ecode2)) {
14200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14201 }
14202 arg2 = static_cast< int >(val2);
14203 ecode3 = SWIG_AsVal_int(obj2, &val3);
14204 if (!SWIG_IsOK(ecode3)) {
14205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14206 }
14207 arg3 = static_cast< int >(val3);
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = (byte)(arg1)->GetGreen(arg2,arg3);
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14215 return resultobj;
14216 fail:
14217 return NULL;
14218 }
14219
14220
14221 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj = 0;
14223 wxImage *arg1 = (wxImage *) 0 ;
14224 int arg2 ;
14225 int arg3 ;
14226 byte result;
14227 void *argp1 = 0 ;
14228 int res1 = 0 ;
14229 int val2 ;
14230 int ecode2 = 0 ;
14231 int val3 ;
14232 int ecode3 = 0 ;
14233 PyObject * obj0 = 0 ;
14234 PyObject * obj1 = 0 ;
14235 PyObject * obj2 = 0 ;
14236 char * kwnames[] = {
14237 (char *) "self",(char *) "x",(char *) "y", NULL
14238 };
14239
14240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14242 if (!SWIG_IsOK(res1)) {
14243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14244 }
14245 arg1 = reinterpret_cast< wxImage * >(argp1);
14246 ecode2 = SWIG_AsVal_int(obj1, &val2);
14247 if (!SWIG_IsOK(ecode2)) {
14248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14249 }
14250 arg2 = static_cast< int >(val2);
14251 ecode3 = SWIG_AsVal_int(obj2, &val3);
14252 if (!SWIG_IsOK(ecode3)) {
14253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14254 }
14255 arg3 = static_cast< int >(val3);
14256 {
14257 PyThreadState* __tstate = wxPyBeginAllowThreads();
14258 result = (byte)(arg1)->GetBlue(arg2,arg3);
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj = 0;
14271 wxImage *arg1 = (wxImage *) 0 ;
14272 int arg2 ;
14273 int arg3 ;
14274 byte arg4 ;
14275 void *argp1 = 0 ;
14276 int res1 = 0 ;
14277 int val2 ;
14278 int ecode2 = 0 ;
14279 int val3 ;
14280 int ecode3 = 0 ;
14281 unsigned char val4 ;
14282 int ecode4 = 0 ;
14283 PyObject * obj0 = 0 ;
14284 PyObject * obj1 = 0 ;
14285 PyObject * obj2 = 0 ;
14286 PyObject * obj3 = 0 ;
14287 char * kwnames[] = {
14288 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14289 };
14290
14291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14293 if (!SWIG_IsOK(res1)) {
14294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14295 }
14296 arg1 = reinterpret_cast< wxImage * >(argp1);
14297 ecode2 = SWIG_AsVal_int(obj1, &val2);
14298 if (!SWIG_IsOK(ecode2)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14300 }
14301 arg2 = static_cast< int >(val2);
14302 ecode3 = SWIG_AsVal_int(obj2, &val3);
14303 if (!SWIG_IsOK(ecode3)) {
14304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14305 }
14306 arg3 = static_cast< int >(val3);
14307 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14308 if (!SWIG_IsOK(ecode4)) {
14309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14310 }
14311 arg4 = static_cast< byte >(val4);
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 (arg1)->SetAlpha(arg2,arg3,arg4);
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 resultobj = SWIG_Py_Void();
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14326 PyObject *resultobj = 0;
14327 wxImage *arg1 = (wxImage *) 0 ;
14328 int arg2 ;
14329 int arg3 ;
14330 byte result;
14331 void *argp1 = 0 ;
14332 int res1 = 0 ;
14333 int val2 ;
14334 int ecode2 = 0 ;
14335 int val3 ;
14336 int ecode3 = 0 ;
14337 PyObject * obj0 = 0 ;
14338 PyObject * obj1 = 0 ;
14339 PyObject * obj2 = 0 ;
14340 char * kwnames[] = {
14341 (char *) "self",(char *) "x",(char *) "y", NULL
14342 };
14343
14344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14346 if (!SWIG_IsOK(res1)) {
14347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14348 }
14349 arg1 = reinterpret_cast< wxImage * >(argp1);
14350 ecode2 = SWIG_AsVal_int(obj1, &val2);
14351 if (!SWIG_IsOK(ecode2)) {
14352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14353 }
14354 arg2 = static_cast< int >(val2);
14355 ecode3 = SWIG_AsVal_int(obj2, &val3);
14356 if (!SWIG_IsOK(ecode3)) {
14357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14358 }
14359 arg3 = static_cast< int >(val3);
14360 {
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14363 wxPyEndAllowThreads(__tstate);
14364 if (PyErr_Occurred()) SWIG_fail;
14365 }
14366 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14367 return resultobj;
14368 fail:
14369 return NULL;
14370 }
14371
14372
14373 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14374 PyObject *resultobj = 0;
14375 wxImage *arg1 = (wxImage *) 0 ;
14376 bool result;
14377 void *argp1 = 0 ;
14378 int res1 = 0 ;
14379 PyObject *swig_obj[1] ;
14380
14381 if (!args) SWIG_fail;
14382 swig_obj[0] = args;
14383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14384 if (!SWIG_IsOK(res1)) {
14385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14386 }
14387 arg1 = reinterpret_cast< wxImage * >(argp1);
14388 {
14389 PyThreadState* __tstate = wxPyBeginAllowThreads();
14390 result = (bool)(arg1)->HasAlpha();
14391 wxPyEndAllowThreads(__tstate);
14392 if (PyErr_Occurred()) SWIG_fail;
14393 }
14394 {
14395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14396 }
14397 return resultobj;
14398 fail:
14399 return NULL;
14400 }
14401
14402
14403 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14404 PyObject *resultobj = 0;
14405 wxImage *arg1 = (wxImage *) 0 ;
14406 void *argp1 = 0 ;
14407 int res1 = 0 ;
14408 PyObject *swig_obj[1] ;
14409
14410 if (!args) SWIG_fail;
14411 swig_obj[0] = args;
14412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14413 if (!SWIG_IsOK(res1)) {
14414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14415 }
14416 arg1 = reinterpret_cast< wxImage * >(argp1);
14417 {
14418 PyThreadState* __tstate = wxPyBeginAllowThreads();
14419 (arg1)->InitAlpha();
14420 wxPyEndAllowThreads(__tstate);
14421 if (PyErr_Occurred()) SWIG_fail;
14422 }
14423 resultobj = SWIG_Py_Void();
14424 return resultobj;
14425 fail:
14426 return NULL;
14427 }
14428
14429
14430 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14431 PyObject *resultobj = 0;
14432 wxImage *arg1 = (wxImage *) 0 ;
14433 int arg2 ;
14434 int arg3 ;
14435 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14436 bool result;
14437 void *argp1 = 0 ;
14438 int res1 = 0 ;
14439 int val2 ;
14440 int ecode2 = 0 ;
14441 int val3 ;
14442 int ecode3 = 0 ;
14443 unsigned char val4 ;
14444 int ecode4 = 0 ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 PyObject * obj2 = 0 ;
14448 PyObject * obj3 = 0 ;
14449 char * kwnames[] = {
14450 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14451 };
14452
14453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14455 if (!SWIG_IsOK(res1)) {
14456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14457 }
14458 arg1 = reinterpret_cast< wxImage * >(argp1);
14459 ecode2 = SWIG_AsVal_int(obj1, &val2);
14460 if (!SWIG_IsOK(ecode2)) {
14461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14462 }
14463 arg2 = static_cast< int >(val2);
14464 ecode3 = SWIG_AsVal_int(obj2, &val3);
14465 if (!SWIG_IsOK(ecode3)) {
14466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14467 }
14468 arg3 = static_cast< int >(val3);
14469 if (obj3) {
14470 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14471 if (!SWIG_IsOK(ecode4)) {
14472 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14473 }
14474 arg4 = static_cast< byte >(val4);
14475 }
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 {
14483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14484 }
14485 return resultobj;
14486 fail:
14487 return NULL;
14488 }
14489
14490
14491 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj = 0;
14493 wxImage *arg1 = (wxImage *) 0 ;
14494 byte *arg2 = (byte *) 0 ;
14495 byte *arg3 = (byte *) 0 ;
14496 byte *arg4 = (byte *) 0 ;
14497 byte arg5 = (byte) 0 ;
14498 byte arg6 = (byte) 0 ;
14499 byte arg7 = (byte) 0 ;
14500 bool result;
14501 void *argp1 = 0 ;
14502 int res1 = 0 ;
14503 byte temp2 ;
14504 int res2 = SWIG_TMPOBJ ;
14505 byte temp3 ;
14506 int res3 = SWIG_TMPOBJ ;
14507 byte temp4 ;
14508 int res4 = SWIG_TMPOBJ ;
14509 unsigned char val5 ;
14510 int ecode5 = 0 ;
14511 unsigned char val6 ;
14512 int ecode6 = 0 ;
14513 unsigned char val7 ;
14514 int ecode7 = 0 ;
14515 PyObject * obj0 = 0 ;
14516 PyObject * obj1 = 0 ;
14517 PyObject * obj2 = 0 ;
14518 PyObject * obj3 = 0 ;
14519 char * kwnames[] = {
14520 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14521 };
14522
14523 arg2 = &temp2;
14524 arg3 = &temp3;
14525 arg4 = &temp4;
14526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14528 if (!SWIG_IsOK(res1)) {
14529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14530 }
14531 arg1 = reinterpret_cast< wxImage * >(argp1);
14532 if (obj1) {
14533 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14534 if (!SWIG_IsOK(ecode5)) {
14535 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14536 }
14537 arg5 = static_cast< byte >(val5);
14538 }
14539 if (obj2) {
14540 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14541 if (!SWIG_IsOK(ecode6)) {
14542 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14543 }
14544 arg6 = static_cast< byte >(val6);
14545 }
14546 if (obj3) {
14547 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14548 if (!SWIG_IsOK(ecode7)) {
14549 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14550 }
14551 arg7 = static_cast< byte >(val7);
14552 }
14553 {
14554 PyThreadState* __tstate = wxPyBeginAllowThreads();
14555 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 {
14560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14561 }
14562 if (SWIG_IsTmpObj(res2)) {
14563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14564 } else {
14565 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14567 }
14568 if (SWIG_IsTmpObj(res3)) {
14569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14570 } else {
14571 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14572 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14573 }
14574 if (SWIG_IsTmpObj(res4)) {
14575 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14576 } else {
14577 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14578 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14579 }
14580 return resultobj;
14581 fail:
14582 return NULL;
14583 }
14584
14585
14586 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14587 PyObject *resultobj = 0;
14588 wxImage *arg1 = (wxImage *) 0 ;
14589 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14590 bool result;
14591 void *argp1 = 0 ;
14592 int res1 = 0 ;
14593 unsigned char val2 ;
14594 int ecode2 = 0 ;
14595 PyObject * obj0 = 0 ;
14596 PyObject * obj1 = 0 ;
14597 char * kwnames[] = {
14598 (char *) "self",(char *) "threshold", NULL
14599 };
14600
14601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14603 if (!SWIG_IsOK(res1)) {
14604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14605 }
14606 arg1 = reinterpret_cast< wxImage * >(argp1);
14607 if (obj1) {
14608 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14609 if (!SWIG_IsOK(ecode2)) {
14610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14611 }
14612 arg2 = static_cast< byte >(val2);
14613 }
14614 {
14615 PyThreadState* __tstate = wxPyBeginAllowThreads();
14616 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14617 wxPyEndAllowThreads(__tstate);
14618 if (PyErr_Occurred()) SWIG_fail;
14619 }
14620 {
14621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14622 }
14623 return resultobj;
14624 fail:
14625 return NULL;
14626 }
14627
14628
14629 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14630 PyObject *resultobj = 0;
14631 wxImage *arg1 = (wxImage *) 0 ;
14632 byte arg2 ;
14633 byte arg3 ;
14634 byte arg4 ;
14635 bool result;
14636 void *argp1 = 0 ;
14637 int res1 = 0 ;
14638 unsigned char val2 ;
14639 int ecode2 = 0 ;
14640 unsigned char val3 ;
14641 int ecode3 = 0 ;
14642 unsigned char val4 ;
14643 int ecode4 = 0 ;
14644 PyObject * obj0 = 0 ;
14645 PyObject * obj1 = 0 ;
14646 PyObject * obj2 = 0 ;
14647 PyObject * obj3 = 0 ;
14648 char * kwnames[] = {
14649 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14650 };
14651
14652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14654 if (!SWIG_IsOK(res1)) {
14655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14656 }
14657 arg1 = reinterpret_cast< wxImage * >(argp1);
14658 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14659 if (!SWIG_IsOK(ecode2)) {
14660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14661 }
14662 arg2 = static_cast< byte >(val2);
14663 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14664 if (!SWIG_IsOK(ecode3)) {
14665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14666 }
14667 arg3 = static_cast< byte >(val3);
14668 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14669 if (!SWIG_IsOK(ecode4)) {
14670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14671 }
14672 arg4 = static_cast< byte >(val4);
14673 {
14674 PyThreadState* __tstate = wxPyBeginAllowThreads();
14675 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14676 wxPyEndAllowThreads(__tstate);
14677 if (PyErr_Occurred()) SWIG_fail;
14678 }
14679 {
14680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14681 }
14682 return resultobj;
14683 fail:
14684 return NULL;
14685 }
14686
14687
14688 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14689 PyObject *resultobj = 0;
14690 wxImage *arg1 = (wxImage *) 0 ;
14691 wxImage *arg2 = 0 ;
14692 byte arg3 ;
14693 byte arg4 ;
14694 byte arg5 ;
14695 bool result;
14696 void *argp1 = 0 ;
14697 int res1 = 0 ;
14698 void *argp2 = 0 ;
14699 int res2 = 0 ;
14700 unsigned char val3 ;
14701 int ecode3 = 0 ;
14702 unsigned char val4 ;
14703 int ecode4 = 0 ;
14704 unsigned char val5 ;
14705 int ecode5 = 0 ;
14706 PyObject * obj0 = 0 ;
14707 PyObject * obj1 = 0 ;
14708 PyObject * obj2 = 0 ;
14709 PyObject * obj3 = 0 ;
14710 PyObject * obj4 = 0 ;
14711 char * kwnames[] = {
14712 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14713 };
14714
14715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14717 if (!SWIG_IsOK(res1)) {
14718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14719 }
14720 arg1 = reinterpret_cast< wxImage * >(argp1);
14721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14722 if (!SWIG_IsOK(res2)) {
14723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14724 }
14725 if (!argp2) {
14726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14727 }
14728 arg2 = reinterpret_cast< wxImage * >(argp2);
14729 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14730 if (!SWIG_IsOK(ecode3)) {
14731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14732 }
14733 arg3 = static_cast< byte >(val3);
14734 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14735 if (!SWIG_IsOK(ecode4)) {
14736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14737 }
14738 arg4 = static_cast< byte >(val4);
14739 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14740 if (!SWIG_IsOK(ecode5)) {
14741 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14742 }
14743 arg5 = static_cast< byte >(val5);
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 {
14751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14752 }
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14760 PyObject *resultobj = 0;
14761 wxString *arg1 = 0 ;
14762 bool result;
14763 bool temp1 = false ;
14764 PyObject * obj0 = 0 ;
14765 char * kwnames[] = {
14766 (char *) "filename", NULL
14767 };
14768
14769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14770 {
14771 arg1 = wxString_in_helper(obj0);
14772 if (arg1 == NULL) SWIG_fail;
14773 temp1 = true;
14774 }
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (bool)wxImage::CanRead((wxString const &)*arg1);
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 (temp1)
14786 delete arg1;
14787 }
14788 return resultobj;
14789 fail:
14790 {
14791 if (temp1)
14792 delete arg1;
14793 }
14794 return NULL;
14795 }
14796
14797
14798 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14799 PyObject *resultobj = 0;
14800 wxString *arg1 = 0 ;
14801 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14802 int result;
14803 bool temp1 = false ;
14804 long val2 ;
14805 int ecode2 = 0 ;
14806 PyObject * obj0 = 0 ;
14807 PyObject * obj1 = 0 ;
14808 char * kwnames[] = {
14809 (char *) "filename",(char *) "type", NULL
14810 };
14811
14812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14813 {
14814 arg1 = wxString_in_helper(obj0);
14815 if (arg1 == NULL) SWIG_fail;
14816 temp1 = true;
14817 }
14818 if (obj1) {
14819 ecode2 = SWIG_AsVal_long(obj1, &val2);
14820 if (!SWIG_IsOK(ecode2)) {
14821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14822 }
14823 arg2 = static_cast< long >(val2);
14824 }
14825 {
14826 PyThreadState* __tstate = wxPyBeginAllowThreads();
14827 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14828 wxPyEndAllowThreads(__tstate);
14829 if (PyErr_Occurred()) SWIG_fail;
14830 }
14831 resultobj = SWIG_From_int(static_cast< int >(result));
14832 {
14833 if (temp1)
14834 delete arg1;
14835 }
14836 return resultobj;
14837 fail:
14838 {
14839 if (temp1)
14840 delete arg1;
14841 }
14842 return NULL;
14843 }
14844
14845
14846 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14847 PyObject *resultobj = 0;
14848 wxImage *arg1 = (wxImage *) 0 ;
14849 wxString *arg2 = 0 ;
14850 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14851 int arg4 = (int) -1 ;
14852 bool result;
14853 void *argp1 = 0 ;
14854 int res1 = 0 ;
14855 bool temp2 = false ;
14856 long val3 ;
14857 int ecode3 = 0 ;
14858 int val4 ;
14859 int ecode4 = 0 ;
14860 PyObject * obj0 = 0 ;
14861 PyObject * obj1 = 0 ;
14862 PyObject * obj2 = 0 ;
14863 PyObject * obj3 = 0 ;
14864 char * kwnames[] = {
14865 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14866 };
14867
14868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14870 if (!SWIG_IsOK(res1)) {
14871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14872 }
14873 arg1 = reinterpret_cast< wxImage * >(argp1);
14874 {
14875 arg2 = wxString_in_helper(obj1);
14876 if (arg2 == NULL) SWIG_fail;
14877 temp2 = true;
14878 }
14879 if (obj2) {
14880 ecode3 = SWIG_AsVal_long(obj2, &val3);
14881 if (!SWIG_IsOK(ecode3)) {
14882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14883 }
14884 arg3 = static_cast< long >(val3);
14885 }
14886 if (obj3) {
14887 ecode4 = SWIG_AsVal_int(obj3, &val4);
14888 if (!SWIG_IsOK(ecode4)) {
14889 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14890 }
14891 arg4 = static_cast< int >(val4);
14892 }
14893 {
14894 PyThreadState* __tstate = wxPyBeginAllowThreads();
14895 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14896 wxPyEndAllowThreads(__tstate);
14897 if (PyErr_Occurred()) SWIG_fail;
14898 }
14899 {
14900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14901 }
14902 {
14903 if (temp2)
14904 delete arg2;
14905 }
14906 return resultobj;
14907 fail:
14908 {
14909 if (temp2)
14910 delete arg2;
14911 }
14912 return NULL;
14913 }
14914
14915
14916 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14917 PyObject *resultobj = 0;
14918 wxImage *arg1 = (wxImage *) 0 ;
14919 wxString *arg2 = 0 ;
14920 wxString *arg3 = 0 ;
14921 int arg4 = (int) -1 ;
14922 bool result;
14923 void *argp1 = 0 ;
14924 int res1 = 0 ;
14925 bool temp2 = false ;
14926 bool temp3 = false ;
14927 int val4 ;
14928 int ecode4 = 0 ;
14929 PyObject * obj0 = 0 ;
14930 PyObject * obj1 = 0 ;
14931 PyObject * obj2 = 0 ;
14932 PyObject * obj3 = 0 ;
14933 char * kwnames[] = {
14934 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14935 };
14936
14937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14939 if (!SWIG_IsOK(res1)) {
14940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14941 }
14942 arg1 = reinterpret_cast< wxImage * >(argp1);
14943 {
14944 arg2 = wxString_in_helper(obj1);
14945 if (arg2 == NULL) SWIG_fail;
14946 temp2 = true;
14947 }
14948 {
14949 arg3 = wxString_in_helper(obj2);
14950 if (arg3 == NULL) SWIG_fail;
14951 temp3 = true;
14952 }
14953 if (obj3) {
14954 ecode4 = SWIG_AsVal_int(obj3, &val4);
14955 if (!SWIG_IsOK(ecode4)) {
14956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14957 }
14958 arg4 = static_cast< int >(val4);
14959 }
14960 {
14961 PyThreadState* __tstate = wxPyBeginAllowThreads();
14962 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14963 wxPyEndAllowThreads(__tstate);
14964 if (PyErr_Occurred()) SWIG_fail;
14965 }
14966 {
14967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14968 }
14969 {
14970 if (temp2)
14971 delete arg2;
14972 }
14973 {
14974 if (temp3)
14975 delete arg3;
14976 }
14977 return resultobj;
14978 fail:
14979 {
14980 if (temp2)
14981 delete arg2;
14982 }
14983 {
14984 if (temp3)
14985 delete arg3;
14986 }
14987 return NULL;
14988 }
14989
14990
14991 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14992 PyObject *resultobj = 0;
14993 wxImage *arg1 = (wxImage *) 0 ;
14994 wxString *arg2 = 0 ;
14995 int arg3 ;
14996 bool result;
14997 void *argp1 = 0 ;
14998 int res1 = 0 ;
14999 bool temp2 = false ;
15000 int val3 ;
15001 int ecode3 = 0 ;
15002 PyObject * obj0 = 0 ;
15003 PyObject * obj1 = 0 ;
15004 PyObject * obj2 = 0 ;
15005 char * kwnames[] = {
15006 (char *) "self",(char *) "name",(char *) "type", NULL
15007 };
15008
15009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15011 if (!SWIG_IsOK(res1)) {
15012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15013 }
15014 arg1 = reinterpret_cast< wxImage * >(argp1);
15015 {
15016 arg2 = wxString_in_helper(obj1);
15017 if (arg2 == NULL) SWIG_fail;
15018 temp2 = true;
15019 }
15020 ecode3 = SWIG_AsVal_int(obj2, &val3);
15021 if (!SWIG_IsOK(ecode3)) {
15022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15023 }
15024 arg3 = static_cast< int >(val3);
15025 {
15026 PyThreadState* __tstate = wxPyBeginAllowThreads();
15027 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 {
15032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15033 }
15034 {
15035 if (temp2)
15036 delete arg2;
15037 }
15038 return resultobj;
15039 fail:
15040 {
15041 if (temp2)
15042 delete arg2;
15043 }
15044 return NULL;
15045 }
15046
15047
15048 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15049 PyObject *resultobj = 0;
15050 wxImage *arg1 = (wxImage *) 0 ;
15051 wxString *arg2 = 0 ;
15052 wxString *arg3 = 0 ;
15053 bool result;
15054 void *argp1 = 0 ;
15055 int res1 = 0 ;
15056 bool temp2 = false ;
15057 bool temp3 = false ;
15058 PyObject * obj0 = 0 ;
15059 PyObject * obj1 = 0 ;
15060 PyObject * obj2 = 0 ;
15061 char * kwnames[] = {
15062 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15063 };
15064
15065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15067 if (!SWIG_IsOK(res1)) {
15068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15069 }
15070 arg1 = reinterpret_cast< wxImage * >(argp1);
15071 {
15072 arg2 = wxString_in_helper(obj1);
15073 if (arg2 == NULL) SWIG_fail;
15074 temp2 = true;
15075 }
15076 {
15077 arg3 = wxString_in_helper(obj2);
15078 if (arg3 == NULL) SWIG_fail;
15079 temp3 = true;
15080 }
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 {
15088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15089 }
15090 {
15091 if (temp2)
15092 delete arg2;
15093 }
15094 {
15095 if (temp3)
15096 delete arg3;
15097 }
15098 return resultobj;
15099 fail:
15100 {
15101 if (temp2)
15102 delete arg2;
15103 }
15104 {
15105 if (temp3)
15106 delete arg3;
15107 }
15108 return NULL;
15109 }
15110
15111
15112 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj = 0;
15114 wxInputStream *arg1 = 0 ;
15115 bool result;
15116 wxPyInputStream *temp1 ;
15117 bool created1 ;
15118 PyObject * obj0 = 0 ;
15119 char * kwnames[] = {
15120 (char *) "stream", NULL
15121 };
15122
15123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15124 {
15125 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15126 arg1 = temp1->m_wxis;
15127 created1 = false;
15128 } else {
15129 PyErr_Clear(); // clear the failure of the wxPyConvert above
15130 arg1 = wxPyCBInputStream_create(obj0, false);
15131 if (arg1 == NULL) {
15132 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15133 SWIG_fail;
15134 }
15135 created1 = true;
15136 }
15137 }
15138 {
15139 PyThreadState* __tstate = wxPyBeginAllowThreads();
15140 result = (bool)wxImage::CanRead(*arg1);
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 {
15145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15146 }
15147 {
15148 if (created1) delete arg1;
15149 }
15150 return resultobj;
15151 fail:
15152 {
15153 if (created1) delete arg1;
15154 }
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15160 PyObject *resultobj = 0;
15161 wxImage *arg1 = (wxImage *) 0 ;
15162 wxInputStream *arg2 = 0 ;
15163 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15164 int arg4 = (int) -1 ;
15165 bool result;
15166 void *argp1 = 0 ;
15167 int res1 = 0 ;
15168 wxPyInputStream *temp2 ;
15169 bool created2 ;
15170 long val3 ;
15171 int ecode3 = 0 ;
15172 int val4 ;
15173 int ecode4 = 0 ;
15174 PyObject * obj0 = 0 ;
15175 PyObject * obj1 = 0 ;
15176 PyObject * obj2 = 0 ;
15177 PyObject * obj3 = 0 ;
15178 char * kwnames[] = {
15179 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15180 };
15181
15182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15184 if (!SWIG_IsOK(res1)) {
15185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15186 }
15187 arg1 = reinterpret_cast< wxImage * >(argp1);
15188 {
15189 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15190 arg2 = temp2->m_wxis;
15191 created2 = false;
15192 } else {
15193 PyErr_Clear(); // clear the failure of the wxPyConvert above
15194 arg2 = wxPyCBInputStream_create(obj1, false);
15195 if (arg2 == NULL) {
15196 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15197 SWIG_fail;
15198 }
15199 created2 = true;
15200 }
15201 }
15202 if (obj2) {
15203 ecode3 = SWIG_AsVal_long(obj2, &val3);
15204 if (!SWIG_IsOK(ecode3)) {
15205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15206 }
15207 arg3 = static_cast< long >(val3);
15208 }
15209 if (obj3) {
15210 ecode4 = SWIG_AsVal_int(obj3, &val4);
15211 if (!SWIG_IsOK(ecode4)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15213 }
15214 arg4 = static_cast< int >(val4);
15215 }
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 {
15223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15224 }
15225 {
15226 if (created2) delete arg2;
15227 }
15228 return resultobj;
15229 fail:
15230 {
15231 if (created2) delete arg2;
15232 }
15233 return NULL;
15234 }
15235
15236
15237 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15238 PyObject *resultobj = 0;
15239 wxImage *arg1 = (wxImage *) 0 ;
15240 wxInputStream *arg2 = 0 ;
15241 wxString *arg3 = 0 ;
15242 int arg4 = (int) -1 ;
15243 bool result;
15244 void *argp1 = 0 ;
15245 int res1 = 0 ;
15246 wxPyInputStream *temp2 ;
15247 bool created2 ;
15248 bool temp3 = false ;
15249 int val4 ;
15250 int ecode4 = 0 ;
15251 PyObject * obj0 = 0 ;
15252 PyObject * obj1 = 0 ;
15253 PyObject * obj2 = 0 ;
15254 PyObject * obj3 = 0 ;
15255 char * kwnames[] = {
15256 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15257 };
15258
15259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15261 if (!SWIG_IsOK(res1)) {
15262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15263 }
15264 arg1 = reinterpret_cast< wxImage * >(argp1);
15265 {
15266 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15267 arg2 = temp2->m_wxis;
15268 created2 = false;
15269 } else {
15270 PyErr_Clear(); // clear the failure of the wxPyConvert above
15271 arg2 = wxPyCBInputStream_create(obj1, false);
15272 if (arg2 == NULL) {
15273 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15274 SWIG_fail;
15275 }
15276 created2 = true;
15277 }
15278 }
15279 {
15280 arg3 = wxString_in_helper(obj2);
15281 if (arg3 == NULL) SWIG_fail;
15282 temp3 = true;
15283 }
15284 if (obj3) {
15285 ecode4 = SWIG_AsVal_int(obj3, &val4);
15286 if (!SWIG_IsOK(ecode4)) {
15287 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15288 }
15289 arg4 = static_cast< int >(val4);
15290 }
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 {
15298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15299 }
15300 {
15301 if (created2) delete arg2;
15302 }
15303 {
15304 if (temp3)
15305 delete arg3;
15306 }
15307 return resultobj;
15308 fail:
15309 {
15310 if (created2) delete arg2;
15311 }
15312 {
15313 if (temp3)
15314 delete arg3;
15315 }
15316 return NULL;
15317 }
15318
15319
15320 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15321 PyObject *resultobj = 0;
15322 wxImage *arg1 = (wxImage *) 0 ;
15323 bool result;
15324 void *argp1 = 0 ;
15325 int res1 = 0 ;
15326 PyObject *swig_obj[1] ;
15327
15328 if (!args) SWIG_fail;
15329 swig_obj[0] = args;
15330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15331 if (!SWIG_IsOK(res1)) {
15332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15333 }
15334 arg1 = reinterpret_cast< wxImage * >(argp1);
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (bool)(arg1)->Ok();
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 {
15342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15343 }
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15351 PyObject *resultobj = 0;
15352 wxImage *arg1 = (wxImage *) 0 ;
15353 int result;
15354 void *argp1 = 0 ;
15355 int res1 = 0 ;
15356 PyObject *swig_obj[1] ;
15357
15358 if (!args) SWIG_fail;
15359 swig_obj[0] = args;
15360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15363 }
15364 arg1 = reinterpret_cast< wxImage * >(argp1);
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = (int)(arg1)->GetWidth();
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 resultobj = SWIG_From_int(static_cast< int >(result));
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15379 PyObject *resultobj = 0;
15380 wxImage *arg1 = (wxImage *) 0 ;
15381 int result;
15382 void *argp1 = 0 ;
15383 int res1 = 0 ;
15384 PyObject *swig_obj[1] ;
15385
15386 if (!args) SWIG_fail;
15387 swig_obj[0] = args;
15388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15389 if (!SWIG_IsOK(res1)) {
15390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15391 }
15392 arg1 = reinterpret_cast< wxImage * >(argp1);
15393 {
15394 PyThreadState* __tstate = wxPyBeginAllowThreads();
15395 result = (int)(arg1)->GetHeight();
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 resultobj = SWIG_From_int(static_cast< int >(result));
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15407 PyObject *resultobj = 0;
15408 wxImage *arg1 = (wxImage *) 0 ;
15409 wxSize result;
15410 void *argp1 = 0 ;
15411 int res1 = 0 ;
15412 PyObject *swig_obj[1] ;
15413
15414 if (!args) SWIG_fail;
15415 swig_obj[0] = args;
15416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15417 if (!SWIG_IsOK(res1)) {
15418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15419 }
15420 arg1 = reinterpret_cast< wxImage * >(argp1);
15421 {
15422 PyThreadState* __tstate = wxPyBeginAllowThreads();
15423 result = wxImage_GetSize(arg1);
15424 wxPyEndAllowThreads(__tstate);
15425 if (PyErr_Occurred()) SWIG_fail;
15426 }
15427 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15435 PyObject *resultobj = 0;
15436 wxImage *arg1 = (wxImage *) 0 ;
15437 wxRect *arg2 = 0 ;
15438 SwigValueWrapper<wxImage > result;
15439 void *argp1 = 0 ;
15440 int res1 = 0 ;
15441 wxRect temp2 ;
15442 PyObject * obj0 = 0 ;
15443 PyObject * obj1 = 0 ;
15444 char * kwnames[] = {
15445 (char *) "self",(char *) "rect", NULL
15446 };
15447
15448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15450 if (!SWIG_IsOK(res1)) {
15451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15452 }
15453 arg1 = reinterpret_cast< wxImage * >(argp1);
15454 {
15455 arg2 = &temp2;
15456 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15457 }
15458 {
15459 PyThreadState* __tstate = wxPyBeginAllowThreads();
15460 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15461 wxPyEndAllowThreads(__tstate);
15462 if (PyErr_Occurred()) SWIG_fail;
15463 }
15464 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj = 0;
15473 wxImage *arg1 = (wxImage *) 0 ;
15474 wxSize *arg2 = 0 ;
15475 wxPoint *arg3 = 0 ;
15476 int arg4 = (int) -1 ;
15477 int arg5 = (int) -1 ;
15478 int arg6 = (int) -1 ;
15479 SwigValueWrapper<wxImage > result;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 wxSize temp2 ;
15483 wxPoint temp3 ;
15484 int val4 ;
15485 int ecode4 = 0 ;
15486 int val5 ;
15487 int ecode5 = 0 ;
15488 int val6 ;
15489 int ecode6 = 0 ;
15490 PyObject * obj0 = 0 ;
15491 PyObject * obj1 = 0 ;
15492 PyObject * obj2 = 0 ;
15493 PyObject * obj3 = 0 ;
15494 PyObject * obj4 = 0 ;
15495 PyObject * obj5 = 0 ;
15496 char * kwnames[] = {
15497 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15498 };
15499
15500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15502 if (!SWIG_IsOK(res1)) {
15503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15504 }
15505 arg1 = reinterpret_cast< wxImage * >(argp1);
15506 {
15507 arg2 = &temp2;
15508 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15509 }
15510 {
15511 arg3 = &temp3;
15512 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15513 }
15514 if (obj3) {
15515 ecode4 = SWIG_AsVal_int(obj3, &val4);
15516 if (!SWIG_IsOK(ecode4)) {
15517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15518 }
15519 arg4 = static_cast< int >(val4);
15520 }
15521 if (obj4) {
15522 ecode5 = SWIG_AsVal_int(obj4, &val5);
15523 if (!SWIG_IsOK(ecode5)) {
15524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15525 }
15526 arg5 = static_cast< int >(val5);
15527 }
15528 if (obj5) {
15529 ecode6 = SWIG_AsVal_int(obj5, &val6);
15530 if (!SWIG_IsOK(ecode6)) {
15531 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15532 }
15533 arg6 = static_cast< int >(val6);
15534 }
15535 {
15536 PyThreadState* __tstate = wxPyBeginAllowThreads();
15537 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15542 return resultobj;
15543 fail:
15544 return NULL;
15545 }
15546
15547
15548 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15549 PyObject *resultobj = 0;
15550 wxImage *arg1 = (wxImage *) 0 ;
15551 SwigValueWrapper<wxImage > result;
15552 void *argp1 = 0 ;
15553 int res1 = 0 ;
15554 PyObject *swig_obj[1] ;
15555
15556 if (!args) SWIG_fail;
15557 swig_obj[0] = args;
15558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15561 }
15562 arg1 = reinterpret_cast< wxImage * >(argp1);
15563 {
15564 PyThreadState* __tstate = wxPyBeginAllowThreads();
15565 result = (arg1)->Copy();
15566 wxPyEndAllowThreads(__tstate);
15567 if (PyErr_Occurred()) SWIG_fail;
15568 }
15569 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15570 return resultobj;
15571 fail:
15572 return NULL;
15573 }
15574
15575
15576 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15577 PyObject *resultobj = 0;
15578 wxImage *arg1 = (wxImage *) 0 ;
15579 wxImage *arg2 = 0 ;
15580 int arg3 ;
15581 int arg4 ;
15582 void *argp1 = 0 ;
15583 int res1 = 0 ;
15584 void *argp2 = 0 ;
15585 int res2 = 0 ;
15586 int val3 ;
15587 int ecode3 = 0 ;
15588 int val4 ;
15589 int ecode4 = 0 ;
15590 PyObject * obj0 = 0 ;
15591 PyObject * obj1 = 0 ;
15592 PyObject * obj2 = 0 ;
15593 PyObject * obj3 = 0 ;
15594 char * kwnames[] = {
15595 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15596 };
15597
15598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15602 }
15603 arg1 = reinterpret_cast< wxImage * >(argp1);
15604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15605 if (!SWIG_IsOK(res2)) {
15606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15607 }
15608 if (!argp2) {
15609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15610 }
15611 arg2 = reinterpret_cast< wxImage * >(argp2);
15612 ecode3 = SWIG_AsVal_int(obj2, &val3);
15613 if (!SWIG_IsOK(ecode3)) {
15614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15615 }
15616 arg3 = static_cast< int >(val3);
15617 ecode4 = SWIG_AsVal_int(obj3, &val4);
15618 if (!SWIG_IsOK(ecode4)) {
15619 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15620 }
15621 arg4 = static_cast< int >(val4);
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_Py_Void();
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15636 PyObject *resultobj = 0;
15637 wxImage *arg1 = (wxImage *) 0 ;
15638 PyObject *result = 0 ;
15639 void *argp1 = 0 ;
15640 int res1 = 0 ;
15641 PyObject *swig_obj[1] ;
15642
15643 if (!args) SWIG_fail;
15644 swig_obj[0] = args;
15645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15646 if (!SWIG_IsOK(res1)) {
15647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15648 }
15649 arg1 = reinterpret_cast< wxImage * >(argp1);
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (PyObject *)wxImage_GetData(arg1);
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 resultobj = result;
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15664 PyObject *resultobj = 0;
15665 wxImage *arg1 = (wxImage *) 0 ;
15666 buffer arg2 ;
15667 int arg3 ;
15668 void *argp1 = 0 ;
15669 int res1 = 0 ;
15670 Py_ssize_t temp2 ;
15671 PyObject * obj0 = 0 ;
15672 PyObject * obj1 = 0 ;
15673 char * kwnames[] = {
15674 (char *) "self",(char *) "data", NULL
15675 };
15676
15677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15679 if (!SWIG_IsOK(res1)) {
15680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15681 }
15682 arg1 = reinterpret_cast< wxImage * >(argp1);
15683 {
15684 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15685 arg3 = (int)temp2;
15686 }
15687 {
15688 PyThreadState* __tstate = wxPyBeginAllowThreads();
15689 wxImage_SetData(arg1,arg2,arg3);
15690 wxPyEndAllowThreads(__tstate);
15691 if (PyErr_Occurred()) SWIG_fail;
15692 }
15693 resultobj = SWIG_Py_Void();
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15701 PyObject *resultobj = 0;
15702 wxImage *arg1 = (wxImage *) 0 ;
15703 PyObject *result = 0 ;
15704 void *argp1 = 0 ;
15705 int res1 = 0 ;
15706 PyObject *swig_obj[1] ;
15707
15708 if (!args) SWIG_fail;
15709 swig_obj[0] = args;
15710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15711 if (!SWIG_IsOK(res1)) {
15712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15713 }
15714 arg1 = reinterpret_cast< wxImage * >(argp1);
15715 {
15716 PyThreadState* __tstate = wxPyBeginAllowThreads();
15717 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15718 wxPyEndAllowThreads(__tstate);
15719 if (PyErr_Occurred()) SWIG_fail;
15720 }
15721 resultobj = result;
15722 return resultobj;
15723 fail:
15724 return NULL;
15725 }
15726
15727
15728 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15729 PyObject *resultobj = 0;
15730 wxImage *arg1 = (wxImage *) 0 ;
15731 buffer arg2 ;
15732 int arg3 ;
15733 void *argp1 = 0 ;
15734 int res1 = 0 ;
15735 Py_ssize_t temp2 ;
15736 PyObject * obj0 = 0 ;
15737 PyObject * obj1 = 0 ;
15738 char * kwnames[] = {
15739 (char *) "self",(char *) "data", NULL
15740 };
15741
15742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15744 if (!SWIG_IsOK(res1)) {
15745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15746 }
15747 arg1 = reinterpret_cast< wxImage * >(argp1);
15748 {
15749 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15750 arg3 = (int)temp2;
15751 }
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 wxImage_SetDataBuffer(arg1,arg2,arg3);
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_Py_Void();
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxImage *arg1 = (wxImage *) 0 ;
15768 PyObject *result = 0 ;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15778 }
15779 arg1 = reinterpret_cast< wxImage * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (PyObject *)wxImage_GetAlphaData(arg1);
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = result;
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15794 PyObject *resultobj = 0;
15795 wxImage *arg1 = (wxImage *) 0 ;
15796 buffer arg2 ;
15797 int arg3 ;
15798 void *argp1 = 0 ;
15799 int res1 = 0 ;
15800 Py_ssize_t temp2 ;
15801 PyObject * obj0 = 0 ;
15802 PyObject * obj1 = 0 ;
15803 char * kwnames[] = {
15804 (char *) "self",(char *) "alpha", NULL
15805 };
15806
15807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15809 if (!SWIG_IsOK(res1)) {
15810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15811 }
15812 arg1 = reinterpret_cast< wxImage * >(argp1);
15813 {
15814 if (obj1 != Py_None) {
15815 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15816 arg3 = (int)temp2;
15817 }
15818 }
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 wxImage_SetAlphaData(arg1,arg2,arg3);
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 resultobj = SWIG_Py_Void();
15826 return resultobj;
15827 fail:
15828 return NULL;
15829 }
15830
15831
15832 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15833 PyObject *resultobj = 0;
15834 wxImage *arg1 = (wxImage *) 0 ;
15835 PyObject *result = 0 ;
15836 void *argp1 = 0 ;
15837 int res1 = 0 ;
15838 PyObject *swig_obj[1] ;
15839
15840 if (!args) SWIG_fail;
15841 swig_obj[0] = args;
15842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15843 if (!SWIG_IsOK(res1)) {
15844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15845 }
15846 arg1 = reinterpret_cast< wxImage * >(argp1);
15847 {
15848 PyThreadState* __tstate = wxPyBeginAllowThreads();
15849 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 resultobj = result;
15854 return resultobj;
15855 fail:
15856 return NULL;
15857 }
15858
15859
15860 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15861 PyObject *resultobj = 0;
15862 wxImage *arg1 = (wxImage *) 0 ;
15863 buffer arg2 ;
15864 int arg3 ;
15865 void *argp1 = 0 ;
15866 int res1 = 0 ;
15867 Py_ssize_t temp2 ;
15868 PyObject * obj0 = 0 ;
15869 PyObject * obj1 = 0 ;
15870 char * kwnames[] = {
15871 (char *) "self",(char *) "alpha", NULL
15872 };
15873
15874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15876 if (!SWIG_IsOK(res1)) {
15877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15878 }
15879 arg1 = reinterpret_cast< wxImage * >(argp1);
15880 {
15881 if (obj1 != Py_None) {
15882 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15883 arg3 = (int)temp2;
15884 }
15885 }
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15889 wxPyEndAllowThreads(__tstate);
15890 if (PyErr_Occurred()) SWIG_fail;
15891 }
15892 resultobj = SWIG_Py_Void();
15893 return resultobj;
15894 fail:
15895 return NULL;
15896 }
15897
15898
15899 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15900 PyObject *resultobj = 0;
15901 wxImage *arg1 = (wxImage *) 0 ;
15902 byte arg2 ;
15903 byte arg3 ;
15904 byte arg4 ;
15905 void *argp1 = 0 ;
15906 int res1 = 0 ;
15907 unsigned char val2 ;
15908 int ecode2 = 0 ;
15909 unsigned char val3 ;
15910 int ecode3 = 0 ;
15911 unsigned char val4 ;
15912 int ecode4 = 0 ;
15913 PyObject * obj0 = 0 ;
15914 PyObject * obj1 = 0 ;
15915 PyObject * obj2 = 0 ;
15916 PyObject * obj3 = 0 ;
15917 char * kwnames[] = {
15918 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15919 };
15920
15921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15923 if (!SWIG_IsOK(res1)) {
15924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15925 }
15926 arg1 = reinterpret_cast< wxImage * >(argp1);
15927 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15928 if (!SWIG_IsOK(ecode2)) {
15929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15930 }
15931 arg2 = static_cast< byte >(val2);
15932 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15933 if (!SWIG_IsOK(ecode3)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15935 }
15936 arg3 = static_cast< byte >(val3);
15937 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15938 if (!SWIG_IsOK(ecode4)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15940 }
15941 arg4 = static_cast< byte >(val4);
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 (arg1)->SetMaskColour(arg2,arg3,arg4);
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 resultobj = SWIG_Py_Void();
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15956 PyObject *resultobj = 0;
15957 wxImage *arg1 = (wxImage *) 0 ;
15958 byte *arg2 = (byte *) 0 ;
15959 byte *arg3 = (byte *) 0 ;
15960 byte *arg4 = (byte *) 0 ;
15961 void *argp1 = 0 ;
15962 int res1 = 0 ;
15963 byte temp2 ;
15964 int res2 = SWIG_TMPOBJ ;
15965 byte temp3 ;
15966 int res3 = SWIG_TMPOBJ ;
15967 byte temp4 ;
15968 int res4 = SWIG_TMPOBJ ;
15969 PyObject *swig_obj[1] ;
15970
15971 arg2 = &temp2;
15972 arg3 = &temp3;
15973 arg4 = &temp4;
15974 if (!args) SWIG_fail;
15975 swig_obj[0] = args;
15976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15977 if (!SWIG_IsOK(res1)) {
15978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15979 }
15980 arg1 = reinterpret_cast< wxImage * >(argp1);
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 resultobj = SWIG_Py_Void();
15988 if (SWIG_IsTmpObj(res2)) {
15989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15990 } else {
15991 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15993 }
15994 if (SWIG_IsTmpObj(res3)) {
15995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15996 } else {
15997 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15999 }
16000 if (SWIG_IsTmpObj(res4)) {
16001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16002 } else {
16003 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16005 }
16006 return resultobj;
16007 fail:
16008 return NULL;
16009 }
16010
16011
16012 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16013 PyObject *resultobj = 0;
16014 wxImage *arg1 = (wxImage *) 0 ;
16015 byte result;
16016 void *argp1 = 0 ;
16017 int res1 = 0 ;
16018 PyObject *swig_obj[1] ;
16019
16020 if (!args) SWIG_fail;
16021 swig_obj[0] = args;
16022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16023 if (!SWIG_IsOK(res1)) {
16024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16025 }
16026 arg1 = reinterpret_cast< wxImage * >(argp1);
16027 {
16028 PyThreadState* __tstate = wxPyBeginAllowThreads();
16029 result = (byte)(arg1)->GetMaskRed();
16030 wxPyEndAllowThreads(__tstate);
16031 if (PyErr_Occurred()) SWIG_fail;
16032 }
16033 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16034 return resultobj;
16035 fail:
16036 return NULL;
16037 }
16038
16039
16040 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16041 PyObject *resultobj = 0;
16042 wxImage *arg1 = (wxImage *) 0 ;
16043 byte result;
16044 void *argp1 = 0 ;
16045 int res1 = 0 ;
16046 PyObject *swig_obj[1] ;
16047
16048 if (!args) SWIG_fail;
16049 swig_obj[0] = args;
16050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16051 if (!SWIG_IsOK(res1)) {
16052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16053 }
16054 arg1 = reinterpret_cast< wxImage * >(argp1);
16055 {
16056 PyThreadState* __tstate = wxPyBeginAllowThreads();
16057 result = (byte)(arg1)->GetMaskGreen();
16058 wxPyEndAllowThreads(__tstate);
16059 if (PyErr_Occurred()) SWIG_fail;
16060 }
16061 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16062 return resultobj;
16063 fail:
16064 return NULL;
16065 }
16066
16067
16068 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16069 PyObject *resultobj = 0;
16070 wxImage *arg1 = (wxImage *) 0 ;
16071 byte result;
16072 void *argp1 = 0 ;
16073 int res1 = 0 ;
16074 PyObject *swig_obj[1] ;
16075
16076 if (!args) SWIG_fail;
16077 swig_obj[0] = args;
16078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16079 if (!SWIG_IsOK(res1)) {
16080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16081 }
16082 arg1 = reinterpret_cast< wxImage * >(argp1);
16083 {
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 result = (byte)(arg1)->GetMaskBlue();
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16090 return resultobj;
16091 fail:
16092 return NULL;
16093 }
16094
16095
16096 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16097 PyObject *resultobj = 0;
16098 wxImage *arg1 = (wxImage *) 0 ;
16099 bool arg2 = (bool) true ;
16100 void *argp1 = 0 ;
16101 int res1 = 0 ;
16102 bool val2 ;
16103 int ecode2 = 0 ;
16104 PyObject * obj0 = 0 ;
16105 PyObject * obj1 = 0 ;
16106 char * kwnames[] = {
16107 (char *) "self",(char *) "mask", NULL
16108 };
16109
16110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16112 if (!SWIG_IsOK(res1)) {
16113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16114 }
16115 arg1 = reinterpret_cast< wxImage * >(argp1);
16116 if (obj1) {
16117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16118 if (!SWIG_IsOK(ecode2)) {
16119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16120 }
16121 arg2 = static_cast< bool >(val2);
16122 }
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 (arg1)->SetMask(arg2);
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 resultobj = SWIG_Py_Void();
16130 return resultobj;
16131 fail:
16132 return NULL;
16133 }
16134
16135
16136 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16137 PyObject *resultobj = 0;
16138 wxImage *arg1 = (wxImage *) 0 ;
16139 bool result;
16140 void *argp1 = 0 ;
16141 int res1 = 0 ;
16142 PyObject *swig_obj[1] ;
16143
16144 if (!args) SWIG_fail;
16145 swig_obj[0] = args;
16146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16147 if (!SWIG_IsOK(res1)) {
16148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16149 }
16150 arg1 = reinterpret_cast< wxImage * >(argp1);
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 result = (bool)(arg1)->HasMask();
16154 wxPyEndAllowThreads(__tstate);
16155 if (PyErr_Occurred()) SWIG_fail;
16156 }
16157 {
16158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16159 }
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16167 PyObject *resultobj = 0;
16168 wxImage *arg1 = (wxImage *) 0 ;
16169 double arg2 ;
16170 wxPoint *arg3 = 0 ;
16171 bool arg4 = (bool) true ;
16172 wxPoint *arg5 = (wxPoint *) NULL ;
16173 SwigValueWrapper<wxImage > result;
16174 void *argp1 = 0 ;
16175 int res1 = 0 ;
16176 double val2 ;
16177 int ecode2 = 0 ;
16178 wxPoint temp3 ;
16179 bool val4 ;
16180 int ecode4 = 0 ;
16181 void *argp5 = 0 ;
16182 int res5 = 0 ;
16183 PyObject * obj0 = 0 ;
16184 PyObject * obj1 = 0 ;
16185 PyObject * obj2 = 0 ;
16186 PyObject * obj3 = 0 ;
16187 PyObject * obj4 = 0 ;
16188 char * kwnames[] = {
16189 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16190 };
16191
16192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16194 if (!SWIG_IsOK(res1)) {
16195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16196 }
16197 arg1 = reinterpret_cast< wxImage * >(argp1);
16198 ecode2 = SWIG_AsVal_double(obj1, &val2);
16199 if (!SWIG_IsOK(ecode2)) {
16200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16201 }
16202 arg2 = static_cast< double >(val2);
16203 {
16204 arg3 = &temp3;
16205 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16206 }
16207 if (obj3) {
16208 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16209 if (!SWIG_IsOK(ecode4)) {
16210 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16211 }
16212 arg4 = static_cast< bool >(val4);
16213 }
16214 if (obj4) {
16215 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16216 if (!SWIG_IsOK(res5)) {
16217 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16218 }
16219 arg5 = reinterpret_cast< wxPoint * >(argp5);
16220 }
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16224 wxPyEndAllowThreads(__tstate);
16225 if (PyErr_Occurred()) SWIG_fail;
16226 }
16227 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16228 return resultobj;
16229 fail:
16230 return NULL;
16231 }
16232
16233
16234 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16235 PyObject *resultobj = 0;
16236 wxImage *arg1 = (wxImage *) 0 ;
16237 bool arg2 = (bool) true ;
16238 SwigValueWrapper<wxImage > result;
16239 void *argp1 = 0 ;
16240 int res1 = 0 ;
16241 bool val2 ;
16242 int ecode2 = 0 ;
16243 PyObject * obj0 = 0 ;
16244 PyObject * obj1 = 0 ;
16245 char * kwnames[] = {
16246 (char *) "self",(char *) "clockwise", NULL
16247 };
16248
16249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16251 if (!SWIG_IsOK(res1)) {
16252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16253 }
16254 arg1 = reinterpret_cast< wxImage * >(argp1);
16255 if (obj1) {
16256 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16257 if (!SWIG_IsOK(ecode2)) {
16258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16259 }
16260 arg2 = static_cast< bool >(val2);
16261 }
16262 {
16263 PyThreadState* __tstate = wxPyBeginAllowThreads();
16264 result = (arg1)->Rotate90(arg2);
16265 wxPyEndAllowThreads(__tstate);
16266 if (PyErr_Occurred()) SWIG_fail;
16267 }
16268 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16269 return resultobj;
16270 fail:
16271 return NULL;
16272 }
16273
16274
16275 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16276 PyObject *resultobj = 0;
16277 wxImage *arg1 = (wxImage *) 0 ;
16278 bool arg2 = (bool) true ;
16279 SwigValueWrapper<wxImage > result;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 bool val2 ;
16283 int ecode2 = 0 ;
16284 PyObject * obj0 = 0 ;
16285 PyObject * obj1 = 0 ;
16286 char * kwnames[] = {
16287 (char *) "self",(char *) "horizontally", NULL
16288 };
16289
16290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16292 if (!SWIG_IsOK(res1)) {
16293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16294 }
16295 arg1 = reinterpret_cast< wxImage * >(argp1);
16296 if (obj1) {
16297 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16298 if (!SWIG_IsOK(ecode2)) {
16299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16300 }
16301 arg2 = static_cast< bool >(val2);
16302 }
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (arg1)->Mirror(arg2);
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16310 return resultobj;
16311 fail:
16312 return NULL;
16313 }
16314
16315
16316 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16317 PyObject *resultobj = 0;
16318 wxImage *arg1 = (wxImage *) 0 ;
16319 byte arg2 ;
16320 byte arg3 ;
16321 byte arg4 ;
16322 byte arg5 ;
16323 byte arg6 ;
16324 byte arg7 ;
16325 void *argp1 = 0 ;
16326 int res1 = 0 ;
16327 unsigned char val2 ;
16328 int ecode2 = 0 ;
16329 unsigned char val3 ;
16330 int ecode3 = 0 ;
16331 unsigned char val4 ;
16332 int ecode4 = 0 ;
16333 unsigned char val5 ;
16334 int ecode5 = 0 ;
16335 unsigned char val6 ;
16336 int ecode6 = 0 ;
16337 unsigned char val7 ;
16338 int ecode7 = 0 ;
16339 PyObject * obj0 = 0 ;
16340 PyObject * obj1 = 0 ;
16341 PyObject * obj2 = 0 ;
16342 PyObject * obj3 = 0 ;
16343 PyObject * obj4 = 0 ;
16344 PyObject * obj5 = 0 ;
16345 PyObject * obj6 = 0 ;
16346 char * kwnames[] = {
16347 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16348 };
16349
16350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16354 }
16355 arg1 = reinterpret_cast< wxImage * >(argp1);
16356 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16357 if (!SWIG_IsOK(ecode2)) {
16358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16359 }
16360 arg2 = static_cast< byte >(val2);
16361 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16362 if (!SWIG_IsOK(ecode3)) {
16363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16364 }
16365 arg3 = static_cast< byte >(val3);
16366 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16367 if (!SWIG_IsOK(ecode4)) {
16368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16369 }
16370 arg4 = static_cast< byte >(val4);
16371 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16372 if (!SWIG_IsOK(ecode5)) {
16373 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16374 }
16375 arg5 = static_cast< byte >(val5);
16376 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16377 if (!SWIG_IsOK(ecode6)) {
16378 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16379 }
16380 arg6 = static_cast< byte >(val6);
16381 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16382 if (!SWIG_IsOK(ecode7)) {
16383 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16384 }
16385 arg7 = static_cast< byte >(val7);
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 resultobj = SWIG_Py_Void();
16393 return resultobj;
16394 fail:
16395 return NULL;
16396 }
16397
16398
16399 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16400 PyObject *resultobj = 0;
16401 wxImage *arg1 = (wxImage *) 0 ;
16402 double arg2 = (double) 0.299 ;
16403 double arg3 = (double) 0.587 ;
16404 double arg4 = (double) 0.114 ;
16405 SwigValueWrapper<wxImage > result;
16406 void *argp1 = 0 ;
16407 int res1 = 0 ;
16408 double val2 ;
16409 int ecode2 = 0 ;
16410 double val3 ;
16411 int ecode3 = 0 ;
16412 double val4 ;
16413 int ecode4 = 0 ;
16414 PyObject * obj0 = 0 ;
16415 PyObject * obj1 = 0 ;
16416 PyObject * obj2 = 0 ;
16417 PyObject * obj3 = 0 ;
16418 char * kwnames[] = {
16419 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16420 };
16421
16422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16426 }
16427 arg1 = reinterpret_cast< wxImage * >(argp1);
16428 if (obj1) {
16429 ecode2 = SWIG_AsVal_double(obj1, &val2);
16430 if (!SWIG_IsOK(ecode2)) {
16431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16432 }
16433 arg2 = static_cast< double >(val2);
16434 }
16435 if (obj2) {
16436 ecode3 = SWIG_AsVal_double(obj2, &val3);
16437 if (!SWIG_IsOK(ecode3)) {
16438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16439 }
16440 arg3 = static_cast< double >(val3);
16441 }
16442 if (obj3) {
16443 ecode4 = SWIG_AsVal_double(obj3, &val4);
16444 if (!SWIG_IsOK(ecode4)) {
16445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16446 }
16447 arg4 = static_cast< double >(val4);
16448 }
16449 {
16450 PyThreadState* __tstate = wxPyBeginAllowThreads();
16451 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16452 wxPyEndAllowThreads(__tstate);
16453 if (PyErr_Occurred()) SWIG_fail;
16454 }
16455 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj = 0;
16464 wxImage *arg1 = (wxImage *) 0 ;
16465 byte arg2 ;
16466 byte arg3 ;
16467 byte arg4 ;
16468 SwigValueWrapper<wxImage > result;
16469 void *argp1 = 0 ;
16470 int res1 = 0 ;
16471 unsigned char val2 ;
16472 int ecode2 = 0 ;
16473 unsigned char val3 ;
16474 int ecode3 = 0 ;
16475 unsigned char val4 ;
16476 int ecode4 = 0 ;
16477 PyObject * obj0 = 0 ;
16478 PyObject * obj1 = 0 ;
16479 PyObject * obj2 = 0 ;
16480 PyObject * obj3 = 0 ;
16481 char * kwnames[] = {
16482 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16483 };
16484
16485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16489 }
16490 arg1 = reinterpret_cast< wxImage * >(argp1);
16491 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16492 if (!SWIG_IsOK(ecode2)) {
16493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16494 }
16495 arg2 = static_cast< byte >(val2);
16496 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16497 if (!SWIG_IsOK(ecode3)) {
16498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16499 }
16500 arg3 = static_cast< byte >(val3);
16501 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16502 if (!SWIG_IsOK(ecode4)) {
16503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16504 }
16505 arg4 = static_cast< byte >(val4);
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16509 wxPyEndAllowThreads(__tstate);
16510 if (PyErr_Occurred()) SWIG_fail;
16511 }
16512 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj = 0;
16521 wxImage *arg1 = (wxImage *) 0 ;
16522 wxString *arg2 = 0 ;
16523 wxString *arg3 = 0 ;
16524 void *argp1 = 0 ;
16525 int res1 = 0 ;
16526 bool temp2 = false ;
16527 bool temp3 = false ;
16528 PyObject * obj0 = 0 ;
16529 PyObject * obj1 = 0 ;
16530 PyObject * obj2 = 0 ;
16531 char * kwnames[] = {
16532 (char *) "self",(char *) "name",(char *) "value", NULL
16533 };
16534
16535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16539 }
16540 arg1 = reinterpret_cast< wxImage * >(argp1);
16541 {
16542 arg2 = wxString_in_helper(obj1);
16543 if (arg2 == NULL) SWIG_fail;
16544 temp2 = true;
16545 }
16546 {
16547 arg3 = wxString_in_helper(obj2);
16548 if (arg3 == NULL) SWIG_fail;
16549 temp3 = true;
16550 }
16551 {
16552 PyThreadState* __tstate = wxPyBeginAllowThreads();
16553 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16554 wxPyEndAllowThreads(__tstate);
16555 if (PyErr_Occurred()) SWIG_fail;
16556 }
16557 resultobj = SWIG_Py_Void();
16558 {
16559 if (temp2)
16560 delete arg2;
16561 }
16562 {
16563 if (temp3)
16564 delete arg3;
16565 }
16566 return resultobj;
16567 fail:
16568 {
16569 if (temp2)
16570 delete arg2;
16571 }
16572 {
16573 if (temp3)
16574 delete arg3;
16575 }
16576 return NULL;
16577 }
16578
16579
16580 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16581 PyObject *resultobj = 0;
16582 wxImage *arg1 = (wxImage *) 0 ;
16583 wxString *arg2 = 0 ;
16584 int arg3 ;
16585 void *argp1 = 0 ;
16586 int res1 = 0 ;
16587 bool temp2 = false ;
16588 int val3 ;
16589 int ecode3 = 0 ;
16590 PyObject * obj0 = 0 ;
16591 PyObject * obj1 = 0 ;
16592 PyObject * obj2 = 0 ;
16593 char * kwnames[] = {
16594 (char *) "self",(char *) "name",(char *) "value", NULL
16595 };
16596
16597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16599 if (!SWIG_IsOK(res1)) {
16600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16601 }
16602 arg1 = reinterpret_cast< wxImage * >(argp1);
16603 {
16604 arg2 = wxString_in_helper(obj1);
16605 if (arg2 == NULL) SWIG_fail;
16606 temp2 = true;
16607 }
16608 ecode3 = SWIG_AsVal_int(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16611 }
16612 arg3 = static_cast< int >(val3);
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 (arg1)->SetOption((wxString const &)*arg2,arg3);
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 resultobj = SWIG_Py_Void();
16620 {
16621 if (temp2)
16622 delete arg2;
16623 }
16624 return resultobj;
16625 fail:
16626 {
16627 if (temp2)
16628 delete arg2;
16629 }
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj = 0;
16636 wxImage *arg1 = (wxImage *) 0 ;
16637 wxString *arg2 = 0 ;
16638 wxString result;
16639 void *argp1 = 0 ;
16640 int res1 = 0 ;
16641 bool temp2 = false ;
16642 PyObject * obj0 = 0 ;
16643 PyObject * obj1 = 0 ;
16644 char * kwnames[] = {
16645 (char *) "self",(char *) "name", NULL
16646 };
16647
16648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16650 if (!SWIG_IsOK(res1)) {
16651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16652 }
16653 arg1 = reinterpret_cast< wxImage * >(argp1);
16654 {
16655 arg2 = wxString_in_helper(obj1);
16656 if (arg2 == NULL) SWIG_fail;
16657 temp2 = true;
16658 }
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16662 wxPyEndAllowThreads(__tstate);
16663 if (PyErr_Occurred()) SWIG_fail;
16664 }
16665 {
16666 #if wxUSE_UNICODE
16667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16668 #else
16669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16670 #endif
16671 }
16672 {
16673 if (temp2)
16674 delete arg2;
16675 }
16676 return resultobj;
16677 fail:
16678 {
16679 if (temp2)
16680 delete arg2;
16681 }
16682 return NULL;
16683 }
16684
16685
16686 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16687 PyObject *resultobj = 0;
16688 wxImage *arg1 = (wxImage *) 0 ;
16689 wxString *arg2 = 0 ;
16690 int result;
16691 void *argp1 = 0 ;
16692 int res1 = 0 ;
16693 bool temp2 = false ;
16694 PyObject * obj0 = 0 ;
16695 PyObject * obj1 = 0 ;
16696 char * kwnames[] = {
16697 (char *) "self",(char *) "name", NULL
16698 };
16699
16700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16702 if (!SWIG_IsOK(res1)) {
16703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16704 }
16705 arg1 = reinterpret_cast< wxImage * >(argp1);
16706 {
16707 arg2 = wxString_in_helper(obj1);
16708 if (arg2 == NULL) SWIG_fail;
16709 temp2 = true;
16710 }
16711 {
16712 PyThreadState* __tstate = wxPyBeginAllowThreads();
16713 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 resultobj = SWIG_From_int(static_cast< int >(result));
16718 {
16719 if (temp2)
16720 delete arg2;
16721 }
16722 return resultobj;
16723 fail:
16724 {
16725 if (temp2)
16726 delete arg2;
16727 }
16728 return NULL;
16729 }
16730
16731
16732 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj = 0;
16734 wxImage *arg1 = (wxImage *) 0 ;
16735 wxString *arg2 = 0 ;
16736 bool result;
16737 void *argp1 = 0 ;
16738 int res1 = 0 ;
16739 bool temp2 = false ;
16740 PyObject * obj0 = 0 ;
16741 PyObject * obj1 = 0 ;
16742 char * kwnames[] = {
16743 (char *) "self",(char *) "name", NULL
16744 };
16745
16746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16748 if (!SWIG_IsOK(res1)) {
16749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16750 }
16751 arg1 = reinterpret_cast< wxImage * >(argp1);
16752 {
16753 arg2 = wxString_in_helper(obj1);
16754 if (arg2 == NULL) SWIG_fail;
16755 temp2 = true;
16756 }
16757 {
16758 PyThreadState* __tstate = wxPyBeginAllowThreads();
16759 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16760 wxPyEndAllowThreads(__tstate);
16761 if (PyErr_Occurred()) SWIG_fail;
16762 }
16763 {
16764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16765 }
16766 {
16767 if (temp2)
16768 delete arg2;
16769 }
16770 return resultobj;
16771 fail:
16772 {
16773 if (temp2)
16774 delete arg2;
16775 }
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImage *arg1 = (wxImage *) 0 ;
16783 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16784 unsigned long result;
16785 void *argp1 = 0 ;
16786 int res1 = 0 ;
16787 unsigned long val2 ;
16788 int ecode2 = 0 ;
16789 PyObject * obj0 = 0 ;
16790 PyObject * obj1 = 0 ;
16791 char * kwnames[] = {
16792 (char *) "self",(char *) "stopafter", NULL
16793 };
16794
16795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16797 if (!SWIG_IsOK(res1)) {
16798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16799 }
16800 arg1 = reinterpret_cast< wxImage * >(argp1);
16801 if (obj1) {
16802 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16803 if (!SWIG_IsOK(ecode2)) {
16804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16805 }
16806 arg2 = static_cast< unsigned long >(val2);
16807 }
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 result = (unsigned long)(arg1)->CountColours(arg2);
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16822 PyObject *resultobj = 0;
16823 wxImage *arg1 = (wxImage *) 0 ;
16824 wxImageHistogram *arg2 = 0 ;
16825 unsigned long result;
16826 void *argp1 = 0 ;
16827 int res1 = 0 ;
16828 void *argp2 = 0 ;
16829 int res2 = 0 ;
16830 PyObject * obj0 = 0 ;
16831 PyObject * obj1 = 0 ;
16832 char * kwnames[] = {
16833 (char *) "self",(char *) "h", NULL
16834 };
16835
16836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16838 if (!SWIG_IsOK(res1)) {
16839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16840 }
16841 arg1 = reinterpret_cast< wxImage * >(argp1);
16842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16843 if (!SWIG_IsOK(res2)) {
16844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16845 }
16846 if (!argp2) {
16847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16848 }
16849 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16864 PyObject *resultobj = 0;
16865 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16866 void *argp1 = 0 ;
16867 int res1 = 0 ;
16868 PyObject * obj0 = 0 ;
16869 char * kwnames[] = {
16870 (char *) "handler", NULL
16871 };
16872
16873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16875 if (!SWIG_IsOK(res1)) {
16876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16877 }
16878 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 wxImage::AddHandler(arg1);
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 resultobj = SWIG_Py_Void();
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj = 0;
16894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 PyObject * obj0 = 0 ;
16898 char * kwnames[] = {
16899 (char *) "handler", NULL
16900 };
16901
16902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16904 if (!SWIG_IsOK(res1)) {
16905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16906 }
16907 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16908 {
16909 PyThreadState* __tstate = wxPyBeginAllowThreads();
16910 wxImage::InsertHandler(arg1);
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 resultobj = SWIG_Py_Void();
16915 return resultobj;
16916 fail:
16917 return NULL;
16918 }
16919
16920
16921 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16922 PyObject *resultobj = 0;
16923 wxString *arg1 = 0 ;
16924 bool result;
16925 bool temp1 = false ;
16926 PyObject * obj0 = 0 ;
16927 char * kwnames[] = {
16928 (char *) "name", NULL
16929 };
16930
16931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16932 {
16933 arg1 = wxString_in_helper(obj0);
16934 if (arg1 == NULL) SWIG_fail;
16935 temp1 = true;
16936 }
16937 {
16938 PyThreadState* __tstate = wxPyBeginAllowThreads();
16939 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 {
16944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16945 }
16946 {
16947 if (temp1)
16948 delete arg1;
16949 }
16950 return resultobj;
16951 fail:
16952 {
16953 if (temp1)
16954 delete arg1;
16955 }
16956 return NULL;
16957 }
16958
16959
16960 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16961 PyObject *resultobj = 0;
16962 PyObject *result = 0 ;
16963
16964 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16965 {
16966 PyThreadState* __tstate = wxPyBeginAllowThreads();
16967 result = (PyObject *)wxImage_GetHandlers();
16968 wxPyEndAllowThreads(__tstate);
16969 if (PyErr_Occurred()) SWIG_fail;
16970 }
16971 resultobj = result;
16972 return resultobj;
16973 fail:
16974 return NULL;
16975 }
16976
16977
16978 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16979 PyObject *resultobj = 0;
16980 wxString result;
16981
16982 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16983 {
16984 PyThreadState* __tstate = wxPyBeginAllowThreads();
16985 result = wxImage::GetImageExtWildcard();
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 {
16990 #if wxUSE_UNICODE
16991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16992 #else
16993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16994 #endif
16995 }
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj = 0;
17004 wxImage *arg1 = (wxImage *) 0 ;
17005 int arg2 = (int) -1 ;
17006 wxBitmap result;
17007 void *argp1 = 0 ;
17008 int res1 = 0 ;
17009 int val2 ;
17010 int ecode2 = 0 ;
17011 PyObject * obj0 = 0 ;
17012 PyObject * obj1 = 0 ;
17013 char * kwnames[] = {
17014 (char *) "self",(char *) "depth", NULL
17015 };
17016
17017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17019 if (!SWIG_IsOK(res1)) {
17020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17021 }
17022 arg1 = reinterpret_cast< wxImage * >(argp1);
17023 if (obj1) {
17024 ecode2 = SWIG_AsVal_int(obj1, &val2);
17025 if (!SWIG_IsOK(ecode2)) {
17026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17027 }
17028 arg2 = static_cast< int >(val2);
17029 }
17030 {
17031 if (!wxPyCheckForApp()) SWIG_fail;
17032 PyThreadState* __tstate = wxPyBeginAllowThreads();
17033 result = wxImage_ConvertToBitmap(arg1,arg2);
17034 wxPyEndAllowThreads(__tstate);
17035 if (PyErr_Occurred()) SWIG_fail;
17036 }
17037 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17038 return resultobj;
17039 fail:
17040 return NULL;
17041 }
17042
17043
17044 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17045 PyObject *resultobj = 0;
17046 wxImage *arg1 = (wxImage *) 0 ;
17047 byte arg2 ;
17048 byte arg3 ;
17049 byte arg4 ;
17050 wxBitmap result;
17051 void *argp1 = 0 ;
17052 int res1 = 0 ;
17053 unsigned char val2 ;
17054 int ecode2 = 0 ;
17055 unsigned char val3 ;
17056 int ecode3 = 0 ;
17057 unsigned char val4 ;
17058 int ecode4 = 0 ;
17059 PyObject * obj0 = 0 ;
17060 PyObject * obj1 = 0 ;
17061 PyObject * obj2 = 0 ;
17062 PyObject * obj3 = 0 ;
17063 char * kwnames[] = {
17064 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17065 };
17066
17067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17069 if (!SWIG_IsOK(res1)) {
17070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17071 }
17072 arg1 = reinterpret_cast< wxImage * >(argp1);
17073 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17074 if (!SWIG_IsOK(ecode2)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17076 }
17077 arg2 = static_cast< byte >(val2);
17078 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17079 if (!SWIG_IsOK(ecode3)) {
17080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17081 }
17082 arg3 = static_cast< byte >(val3);
17083 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17084 if (!SWIG_IsOK(ecode4)) {
17085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17086 }
17087 arg4 = static_cast< byte >(val4);
17088 {
17089 if (!wxPyCheckForApp()) SWIG_fail;
17090 PyThreadState* __tstate = wxPyBeginAllowThreads();
17091 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17092 wxPyEndAllowThreads(__tstate);
17093 if (PyErr_Occurred()) SWIG_fail;
17094 }
17095 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj = 0;
17104 wxImage *arg1 = (wxImage *) 0 ;
17105 double arg2 ;
17106 void *argp1 = 0 ;
17107 int res1 = 0 ;
17108 double val2 ;
17109 int ecode2 = 0 ;
17110 PyObject * obj0 = 0 ;
17111 PyObject * obj1 = 0 ;
17112 char * kwnames[] = {
17113 (char *) "self",(char *) "angle", NULL
17114 };
17115
17116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17118 if (!SWIG_IsOK(res1)) {
17119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17120 }
17121 arg1 = reinterpret_cast< wxImage * >(argp1);
17122 ecode2 = SWIG_AsVal_double(obj1, &val2);
17123 if (!SWIG_IsOK(ecode2)) {
17124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17125 }
17126 arg2 = static_cast< double >(val2);
17127 {
17128 PyThreadState* __tstate = wxPyBeginAllowThreads();
17129 (arg1)->RotateHue(arg2);
17130 wxPyEndAllowThreads(__tstate);
17131 if (PyErr_Occurred()) SWIG_fail;
17132 }
17133 resultobj = SWIG_Py_Void();
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj = 0;
17142 wxImage_RGBValue arg1 ;
17143 wxImage_HSVValue result;
17144 void *argp1 ;
17145 int res1 = 0 ;
17146 PyObject * obj0 = 0 ;
17147 char * kwnames[] = {
17148 (char *) "rgb", NULL
17149 };
17150
17151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17152 {
17153 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17154 if (!SWIG_IsOK(res1)) {
17155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17156 }
17157 if (!argp1) {
17158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17159 } else {
17160 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17161 arg1 = *temp;
17162 if (SWIG_IsNewObj(res1)) delete temp;
17163 }
17164 }
17165 {
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = wxImage::RGBtoHSV(arg1);
17168 wxPyEndAllowThreads(__tstate);
17169 if (PyErr_Occurred()) SWIG_fail;
17170 }
17171 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17172 return resultobj;
17173 fail:
17174 return NULL;
17175 }
17176
17177
17178 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj = 0;
17180 wxImage_HSVValue arg1 ;
17181 wxImage_RGBValue result;
17182 void *argp1 ;
17183 int res1 = 0 ;
17184 PyObject * obj0 = 0 ;
17185 char * kwnames[] = {
17186 (char *) "hsv", NULL
17187 };
17188
17189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17190 {
17191 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17192 if (!SWIG_IsOK(res1)) {
17193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17194 }
17195 if (!argp1) {
17196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17197 } else {
17198 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17199 arg1 = *temp;
17200 if (SWIG_IsNewObj(res1)) delete temp;
17201 }
17202 }
17203 {
17204 PyThreadState* __tstate = wxPyBeginAllowThreads();
17205 result = wxImage::HSVtoRGB(arg1);
17206 wxPyEndAllowThreads(__tstate);
17207 if (PyErr_Occurred()) SWIG_fail;
17208 }
17209 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17210 return resultobj;
17211 fail:
17212 return NULL;
17213 }
17214
17215
17216 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17217 PyObject *obj;
17218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17219 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17220 return SWIG_Py_Void();
17221 }
17222
17223 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17224 return SWIG_Python_InitShadowInstance(args);
17225 }
17226
17227 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj = 0;
17229 int arg1 ;
17230 int arg2 ;
17231 buffer arg3 ;
17232 int arg4 ;
17233 buffer arg5 = (buffer) NULL ;
17234 int arg6 = (int) 0 ;
17235 wxImage *result = 0 ;
17236 int val1 ;
17237 int ecode1 = 0 ;
17238 int val2 ;
17239 int ecode2 = 0 ;
17240 Py_ssize_t temp3 ;
17241 Py_ssize_t temp5 ;
17242 PyObject * obj0 = 0 ;
17243 PyObject * obj1 = 0 ;
17244 PyObject * obj2 = 0 ;
17245 PyObject * obj3 = 0 ;
17246 char * kwnames[] = {
17247 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17248 };
17249
17250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17251 ecode1 = SWIG_AsVal_int(obj0, &val1);
17252 if (!SWIG_IsOK(ecode1)) {
17253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17254 }
17255 arg1 = static_cast< int >(val1);
17256 ecode2 = SWIG_AsVal_int(obj1, &val2);
17257 if (!SWIG_IsOK(ecode2)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17259 }
17260 arg2 = static_cast< int >(val2);
17261 {
17262 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17263 arg4 = (int)temp3;
17264 }
17265 if (obj3) {
17266 {
17267 if (obj3 != Py_None) {
17268 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17269 arg6 = (int)temp5;
17270 }
17271 }
17272 }
17273 {
17274 PyThreadState* __tstate = wxPyBeginAllowThreads();
17275 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17276 wxPyEndAllowThreads(__tstate);
17277 if (PyErr_Occurred()) SWIG_fail;
17278 }
17279 {
17280 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17281 }
17282 return resultobj;
17283 fail:
17284 return NULL;
17285 }
17286
17287
17288 SWIGINTERN int NullImage_set(PyObject *) {
17289 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17290 return 1;
17291 }
17292
17293
17294 SWIGINTERN PyObject *NullImage_get(void) {
17295 PyObject *pyobj = 0;
17296
17297 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17298 return pyobj;
17299 }
17300
17301
17302 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17303 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17304 return 1;
17305 }
17306
17307
17308 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17309 PyObject *pyobj = 0;
17310
17311 {
17312 #if wxUSE_UNICODE
17313 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17314 #else
17315 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17316 #endif
17317 }
17318 return pyobj;
17319 }
17320
17321
17322 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17323 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17324 return 1;
17325 }
17326
17327
17328 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17329 PyObject *pyobj = 0;
17330
17331 {
17332 #if wxUSE_UNICODE
17333 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17334 #else
17335 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17336 #endif
17337 }
17338 return pyobj;
17339 }
17340
17341
17342 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17343 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17344 return 1;
17345 }
17346
17347
17348 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17349 PyObject *pyobj = 0;
17350
17351 {
17352 #if wxUSE_UNICODE
17353 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17354 #else
17355 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17356 #endif
17357 }
17358 return pyobj;
17359 }
17360
17361
17362 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17363 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17364 return 1;
17365 }
17366
17367
17368 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17369 PyObject *pyobj = 0;
17370
17371 {
17372 #if wxUSE_UNICODE
17373 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17374 #else
17375 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17376 #endif
17377 }
17378 return pyobj;
17379 }
17380
17381
17382 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17383 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17384 return 1;
17385 }
17386
17387
17388 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17389 PyObject *pyobj = 0;
17390
17391 {
17392 #if wxUSE_UNICODE
17393 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17394 #else
17395 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17396 #endif
17397 }
17398 return pyobj;
17399 }
17400
17401
17402 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17403 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17404 return 1;
17405 }
17406
17407
17408 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17409 PyObject *pyobj = 0;
17410
17411 {
17412 #if wxUSE_UNICODE
17413 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17414 #else
17415 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17416 #endif
17417 }
17418 return pyobj;
17419 }
17420
17421
17422 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17423 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17424 return 1;
17425 }
17426
17427
17428 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17429 PyObject *pyobj = 0;
17430
17431 {
17432 #if wxUSE_UNICODE
17433 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17434 #else
17435 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17436 #endif
17437 }
17438 return pyobj;
17439 }
17440
17441
17442 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17443 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17444 return 1;
17445 }
17446
17447
17448 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17449 PyObject *pyobj = 0;
17450
17451 {
17452 #if wxUSE_UNICODE
17453 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17454 #else
17455 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17456 #endif
17457 }
17458 return pyobj;
17459 }
17460
17461
17462 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17463 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17464 return 1;
17465 }
17466
17467
17468 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17469 PyObject *pyobj = 0;
17470
17471 {
17472 #if wxUSE_UNICODE
17473 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17474 #else
17475 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17476 #endif
17477 }
17478 return pyobj;
17479 }
17480
17481
17482 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17483 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17484 return 1;
17485 }
17486
17487
17488 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17489 PyObject *pyobj = 0;
17490
17491 {
17492 #if wxUSE_UNICODE
17493 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17494 #else
17495 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17496 #endif
17497 }
17498 return pyobj;
17499 }
17500
17501
17502 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17503 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17504 return 1;
17505 }
17506
17507
17508 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17509 PyObject *pyobj = 0;
17510
17511 {
17512 #if wxUSE_UNICODE
17513 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17514 #else
17515 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17516 #endif
17517 }
17518 return pyobj;
17519 }
17520
17521
17522 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17523 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17524 return 1;
17525 }
17526
17527
17528 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17529 PyObject *pyobj = 0;
17530
17531 {
17532 #if wxUSE_UNICODE
17533 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17534 #else
17535 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17536 #endif
17537 }
17538 return pyobj;
17539 }
17540
17541
17542 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17543 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17544 return 1;
17545 }
17546
17547
17548 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17549 PyObject *pyobj = 0;
17550
17551 {
17552 #if wxUSE_UNICODE
17553 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17554 #else
17555 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17556 #endif
17557 }
17558 return pyobj;
17559 }
17560
17561
17562 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17563 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17564 return 1;
17565 }
17566
17567
17568 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17569 PyObject *pyobj = 0;
17570
17571 {
17572 #if wxUSE_UNICODE
17573 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17574 #else
17575 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17576 #endif
17577 }
17578 return pyobj;
17579 }
17580
17581
17582 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17583 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17584 return 1;
17585 }
17586
17587
17588 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17589 PyObject *pyobj = 0;
17590
17591 {
17592 #if wxUSE_UNICODE
17593 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17594 #else
17595 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17596 #endif
17597 }
17598 return pyobj;
17599 }
17600
17601
17602 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 PyObject *resultobj = 0;
17604 wxBMPHandler *result = 0 ;
17605
17606 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (wxBMPHandler *)new wxBMPHandler();
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *obj;
17622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17623 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17624 return SWIG_Py_Void();
17625 }
17626
17627 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17628 return SWIG_Python_InitShadowInstance(args);
17629 }
17630
17631 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 PyObject *resultobj = 0;
17633 wxICOHandler *result = 0 ;
17634
17635 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17636 {
17637 PyThreadState* __tstate = wxPyBeginAllowThreads();
17638 result = (wxICOHandler *)new wxICOHandler();
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17650 PyObject *obj;
17651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17652 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17653 return SWIG_Py_Void();
17654 }
17655
17656 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17657 return SWIG_Python_InitShadowInstance(args);
17658 }
17659
17660 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17661 PyObject *resultobj = 0;
17662 wxCURHandler *result = 0 ;
17663
17664 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (wxCURHandler *)new wxCURHandler();
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17679 PyObject *obj;
17680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17681 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17682 return SWIG_Py_Void();
17683 }
17684
17685 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17686 return SWIG_Python_InitShadowInstance(args);
17687 }
17688
17689 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 PyObject *resultobj = 0;
17691 wxANIHandler *result = 0 ;
17692
17693 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 result = (wxANIHandler *)new wxANIHandler();
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17701 return resultobj;
17702 fail:
17703 return NULL;
17704 }
17705
17706
17707 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17708 PyObject *obj;
17709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17710 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17711 return SWIG_Py_Void();
17712 }
17713
17714 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17715 return SWIG_Python_InitShadowInstance(args);
17716 }
17717
17718 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17719 PyObject *resultobj = 0;
17720 wxPNGHandler *result = 0 ;
17721
17722 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17723 {
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 result = (wxPNGHandler *)new wxPNGHandler();
17726 wxPyEndAllowThreads(__tstate);
17727 if (PyErr_Occurred()) SWIG_fail;
17728 }
17729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17730 return resultobj;
17731 fail:
17732 return NULL;
17733 }
17734
17735
17736 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737 PyObject *obj;
17738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17739 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17740 return SWIG_Py_Void();
17741 }
17742
17743 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17744 return SWIG_Python_InitShadowInstance(args);
17745 }
17746
17747 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17748 PyObject *resultobj = 0;
17749 wxGIFHandler *result = 0 ;
17750
17751 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (wxGIFHandler *)new wxGIFHandler();
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17766 PyObject *obj;
17767 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17768 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17769 return SWIG_Py_Void();
17770 }
17771
17772 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17773 return SWIG_Python_InitShadowInstance(args);
17774 }
17775
17776 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17777 PyObject *resultobj = 0;
17778 wxPCXHandler *result = 0 ;
17779
17780 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 result = (wxPCXHandler *)new wxPCXHandler();
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17788 return resultobj;
17789 fail:
17790 return NULL;
17791 }
17792
17793
17794 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17795 PyObject *obj;
17796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17797 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17798 return SWIG_Py_Void();
17799 }
17800
17801 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17802 return SWIG_Python_InitShadowInstance(args);
17803 }
17804
17805 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17806 PyObject *resultobj = 0;
17807 wxJPEGHandler *result = 0 ;
17808
17809 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 result = (wxJPEGHandler *)new wxJPEGHandler();
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17817 return resultobj;
17818 fail:
17819 return NULL;
17820 }
17821
17822
17823 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17824 PyObject *obj;
17825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17826 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17827 return SWIG_Py_Void();
17828 }
17829
17830 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17831 return SWIG_Python_InitShadowInstance(args);
17832 }
17833
17834 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17835 PyObject *resultobj = 0;
17836 wxPNMHandler *result = 0 ;
17837
17838 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17839 {
17840 PyThreadState* __tstate = wxPyBeginAllowThreads();
17841 result = (wxPNMHandler *)new wxPNMHandler();
17842 wxPyEndAllowThreads(__tstate);
17843 if (PyErr_Occurred()) SWIG_fail;
17844 }
17845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17846 return resultobj;
17847 fail:
17848 return NULL;
17849 }
17850
17851
17852 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17853 PyObject *obj;
17854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17855 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17856 return SWIG_Py_Void();
17857 }
17858
17859 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17860 return SWIG_Python_InitShadowInstance(args);
17861 }
17862
17863 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17864 PyObject *resultobj = 0;
17865 wxXPMHandler *result = 0 ;
17866
17867 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17868 {
17869 PyThreadState* __tstate = wxPyBeginAllowThreads();
17870 result = (wxXPMHandler *)new wxXPMHandler();
17871 wxPyEndAllowThreads(__tstate);
17872 if (PyErr_Occurred()) SWIG_fail;
17873 }
17874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17882 PyObject *obj;
17883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17884 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17885 return SWIG_Py_Void();
17886 }
17887
17888 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17889 return SWIG_Python_InitShadowInstance(args);
17890 }
17891
17892 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17893 PyObject *resultobj = 0;
17894 wxTIFFHandler *result = 0 ;
17895
17896 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (wxTIFFHandler *)new wxTIFFHandler();
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17911 PyObject *obj;
17912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17913 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17914 return SWIG_Py_Void();
17915 }
17916
17917 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17918 return SWIG_Python_InitShadowInstance(args);
17919 }
17920
17921 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj = 0;
17923 wxImage *arg1 = 0 ;
17924 wxImage *arg2 = 0 ;
17925 int arg3 = (int) 236 ;
17926 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17927 bool result;
17928 void *argp1 = 0 ;
17929 int res1 = 0 ;
17930 void *argp2 = 0 ;
17931 int res2 = 0 ;
17932 int val3 ;
17933 int ecode3 = 0 ;
17934 int val4 ;
17935 int ecode4 = 0 ;
17936 PyObject * obj0 = 0 ;
17937 PyObject * obj1 = 0 ;
17938 PyObject * obj2 = 0 ;
17939 PyObject * obj3 = 0 ;
17940 char * kwnames[] = {
17941 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17942 };
17943
17944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17945 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17946 if (!SWIG_IsOK(res1)) {
17947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17948 }
17949 if (!argp1) {
17950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17951 }
17952 arg1 = reinterpret_cast< wxImage * >(argp1);
17953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17954 if (!SWIG_IsOK(res2)) {
17955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17956 }
17957 if (!argp2) {
17958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17959 }
17960 arg2 = reinterpret_cast< wxImage * >(argp2);
17961 if (obj2) {
17962 ecode3 = SWIG_AsVal_int(obj2, &val3);
17963 if (!SWIG_IsOK(ecode3)) {
17964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17965 }
17966 arg3 = static_cast< int >(val3);
17967 }
17968 if (obj3) {
17969 ecode4 = SWIG_AsVal_int(obj3, &val4);
17970 if (!SWIG_IsOK(ecode4)) {
17971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17972 }
17973 arg4 = static_cast< int >(val4);
17974 }
17975 {
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 {
17982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17983 }
17984 return resultobj;
17985 fail:
17986 return NULL;
17987 }
17988
17989
17990 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17991 PyObject *obj;
17992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17993 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17994 return SWIG_Py_Void();
17995 }
17996
17997 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17998 PyObject *resultobj = 0;
17999 wxEvtHandler *result = 0 ;
18000
18001 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18002 {
18003 PyThreadState* __tstate = wxPyBeginAllowThreads();
18004 result = (wxEvtHandler *)new wxEvtHandler();
18005 wxPyEndAllowThreads(__tstate);
18006 if (PyErr_Occurred()) SWIG_fail;
18007 }
18008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18009 return resultobj;
18010 fail:
18011 return NULL;
18012 }
18013
18014
18015 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18016 PyObject *resultobj = 0;
18017 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18018 wxEvtHandler *result = 0 ;
18019 void *argp1 = 0 ;
18020 int res1 = 0 ;
18021 PyObject *swig_obj[1] ;
18022
18023 if (!args) SWIG_fail;
18024 swig_obj[0] = args;
18025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18026 if (!SWIG_IsOK(res1)) {
18027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18028 }
18029 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18030 {
18031 PyThreadState* __tstate = wxPyBeginAllowThreads();
18032 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18033 wxPyEndAllowThreads(__tstate);
18034 if (PyErr_Occurred()) SWIG_fail;
18035 }
18036 {
18037 resultobj = wxPyMake_wxObject(result, 0);
18038 }
18039 return resultobj;
18040 fail:
18041 return NULL;
18042 }
18043
18044
18045 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18046 PyObject *resultobj = 0;
18047 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18048 wxEvtHandler *result = 0 ;
18049 void *argp1 = 0 ;
18050 int res1 = 0 ;
18051 PyObject *swig_obj[1] ;
18052
18053 if (!args) SWIG_fail;
18054 swig_obj[0] = args;
18055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18056 if (!SWIG_IsOK(res1)) {
18057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18058 }
18059 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18060 {
18061 PyThreadState* __tstate = wxPyBeginAllowThreads();
18062 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18063 wxPyEndAllowThreads(__tstate);
18064 if (PyErr_Occurred()) SWIG_fail;
18065 }
18066 {
18067 resultobj = wxPyMake_wxObject(result, 0);
18068 }
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18076 PyObject *resultobj = 0;
18077 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18078 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 void *argp2 = 0 ;
18082 int res2 = 0 ;
18083 PyObject * obj0 = 0 ;
18084 PyObject * obj1 = 0 ;
18085 char * kwnames[] = {
18086 (char *) "self",(char *) "handler", NULL
18087 };
18088
18089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18091 if (!SWIG_IsOK(res1)) {
18092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18093 }
18094 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18095 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18096 if (!SWIG_IsOK(res2)) {
18097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18098 }
18099 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18100 {
18101 PyThreadState* __tstate = wxPyBeginAllowThreads();
18102 (arg1)->SetNextHandler(arg2);
18103 wxPyEndAllowThreads(__tstate);
18104 if (PyErr_Occurred()) SWIG_fail;
18105 }
18106 resultobj = SWIG_Py_Void();
18107 return resultobj;
18108 fail:
18109 return NULL;
18110 }
18111
18112
18113 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18114 PyObject *resultobj = 0;
18115 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18116 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18117 void *argp1 = 0 ;
18118 int res1 = 0 ;
18119 void *argp2 = 0 ;
18120 int res2 = 0 ;
18121 PyObject * obj0 = 0 ;
18122 PyObject * obj1 = 0 ;
18123 char * kwnames[] = {
18124 (char *) "self",(char *) "handler", NULL
18125 };
18126
18127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18129 if (!SWIG_IsOK(res1)) {
18130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18131 }
18132 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18134 if (!SWIG_IsOK(res2)) {
18135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18136 }
18137 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18138 {
18139 PyThreadState* __tstate = wxPyBeginAllowThreads();
18140 (arg1)->SetPreviousHandler(arg2);
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 resultobj = SWIG_Py_Void();
18145 return resultobj;
18146 fail:
18147 return NULL;
18148 }
18149
18150
18151 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18152 PyObject *resultobj = 0;
18153 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18154 bool result;
18155 void *argp1 = 0 ;
18156 int res1 = 0 ;
18157 PyObject *swig_obj[1] ;
18158
18159 if (!args) SWIG_fail;
18160 swig_obj[0] = args;
18161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18162 if (!SWIG_IsOK(res1)) {
18163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18164 }
18165 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18166 {
18167 PyThreadState* __tstate = wxPyBeginAllowThreads();
18168 result = (bool)(arg1)->GetEvtHandlerEnabled();
18169 wxPyEndAllowThreads(__tstate);
18170 if (PyErr_Occurred()) SWIG_fail;
18171 }
18172 {
18173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18174 }
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18182 PyObject *resultobj = 0;
18183 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18184 bool arg2 ;
18185 void *argp1 = 0 ;
18186 int res1 = 0 ;
18187 bool val2 ;
18188 int ecode2 = 0 ;
18189 PyObject * obj0 = 0 ;
18190 PyObject * obj1 = 0 ;
18191 char * kwnames[] = {
18192 (char *) "self",(char *) "enabled", NULL
18193 };
18194
18195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18197 if (!SWIG_IsOK(res1)) {
18198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18199 }
18200 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18201 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18202 if (!SWIG_IsOK(ecode2)) {
18203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18204 }
18205 arg2 = static_cast< bool >(val2);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 (arg1)->SetEvtHandlerEnabled(arg2);
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = SWIG_Py_Void();
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj = 0;
18221 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18222 wxEvent *arg2 = 0 ;
18223 bool result;
18224 void *argp1 = 0 ;
18225 int res1 = 0 ;
18226 void *argp2 = 0 ;
18227 int res2 = 0 ;
18228 PyObject * obj0 = 0 ;
18229 PyObject * obj1 = 0 ;
18230 char * kwnames[] = {
18231 (char *) "self",(char *) "event", NULL
18232 };
18233
18234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18236 if (!SWIG_IsOK(res1)) {
18237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18238 }
18239 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18240 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18241 if (!SWIG_IsOK(res2)) {
18242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18243 }
18244 if (!argp2) {
18245 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18246 }
18247 arg2 = reinterpret_cast< wxEvent * >(argp2);
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 result = (bool)(arg1)->ProcessEvent(*arg2);
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 {
18255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18256 }
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj = 0;
18265 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18266 wxEvent *arg2 = 0 ;
18267 void *argp1 = 0 ;
18268 int res1 = 0 ;
18269 void *argp2 = 0 ;
18270 int res2 = 0 ;
18271 PyObject * obj0 = 0 ;
18272 PyObject * obj1 = 0 ;
18273 char * kwnames[] = {
18274 (char *) "self",(char *) "event", NULL
18275 };
18276
18277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18279 if (!SWIG_IsOK(res1)) {
18280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18281 }
18282 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18284 if (!SWIG_IsOK(res2)) {
18285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18286 }
18287 if (!argp2) {
18288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18289 }
18290 arg2 = reinterpret_cast< wxEvent * >(argp2);
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 (arg1)->AddPendingEvent(*arg2);
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 resultobj = SWIG_Py_Void();
18298 return resultobj;
18299 fail:
18300 return NULL;
18301 }
18302
18303
18304 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18305 PyObject *resultobj = 0;
18306 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18307 void *argp1 = 0 ;
18308 int res1 = 0 ;
18309 PyObject *swig_obj[1] ;
18310
18311 if (!args) SWIG_fail;
18312 swig_obj[0] = args;
18313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18314 if (!SWIG_IsOK(res1)) {
18315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18316 }
18317 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 (arg1)->ProcessPendingEvents();
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = SWIG_Py_Void();
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj = 0;
18333 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18334 int arg2 ;
18335 int arg3 ;
18336 int arg4 ;
18337 PyObject *arg5 = (PyObject *) 0 ;
18338 void *argp1 = 0 ;
18339 int res1 = 0 ;
18340 int val2 ;
18341 int ecode2 = 0 ;
18342 int val3 ;
18343 int ecode3 = 0 ;
18344 int val4 ;
18345 int ecode4 = 0 ;
18346 PyObject * obj0 = 0 ;
18347 PyObject * obj1 = 0 ;
18348 PyObject * obj2 = 0 ;
18349 PyObject * obj3 = 0 ;
18350 PyObject * obj4 = 0 ;
18351 char * kwnames[] = {
18352 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18353 };
18354
18355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18357 if (!SWIG_IsOK(res1)) {
18358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18359 }
18360 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18361 ecode2 = SWIG_AsVal_int(obj1, &val2);
18362 if (!SWIG_IsOK(ecode2)) {
18363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18364 }
18365 arg2 = static_cast< int >(val2);
18366 ecode3 = SWIG_AsVal_int(obj2, &val3);
18367 if (!SWIG_IsOK(ecode3)) {
18368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18369 }
18370 arg3 = static_cast< int >(val3);
18371 ecode4 = SWIG_AsVal_int(obj3, &val4);
18372 if (!SWIG_IsOK(ecode4)) {
18373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18374 }
18375 arg4 = static_cast< int >(val4);
18376 arg5 = obj4;
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18380 wxPyEndAllowThreads(__tstate);
18381 if (PyErr_Occurred()) SWIG_fail;
18382 }
18383 resultobj = SWIG_Py_Void();
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj = 0;
18392 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18393 int arg2 ;
18394 int arg3 = (int) -1 ;
18395 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18396 bool result;
18397 void *argp1 = 0 ;
18398 int res1 = 0 ;
18399 int val2 ;
18400 int ecode2 = 0 ;
18401 int val3 ;
18402 int ecode3 = 0 ;
18403 int val4 ;
18404 int ecode4 = 0 ;
18405 PyObject * obj0 = 0 ;
18406 PyObject * obj1 = 0 ;
18407 PyObject * obj2 = 0 ;
18408 PyObject * obj3 = 0 ;
18409 char * kwnames[] = {
18410 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18411 };
18412
18413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18415 if (!SWIG_IsOK(res1)) {
18416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18417 }
18418 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18419 ecode2 = SWIG_AsVal_int(obj1, &val2);
18420 if (!SWIG_IsOK(ecode2)) {
18421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18422 }
18423 arg2 = static_cast< int >(val2);
18424 if (obj2) {
18425 ecode3 = SWIG_AsVal_int(obj2, &val3);
18426 if (!SWIG_IsOK(ecode3)) {
18427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18428 }
18429 arg3 = static_cast< int >(val3);
18430 }
18431 if (obj3) {
18432 ecode4 = SWIG_AsVal_int(obj3, &val4);
18433 if (!SWIG_IsOK(ecode4)) {
18434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18435 }
18436 arg4 = static_cast< wxEventType >(val4);
18437 }
18438 {
18439 PyThreadState* __tstate = wxPyBeginAllowThreads();
18440 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18441 wxPyEndAllowThreads(__tstate);
18442 if (PyErr_Occurred()) SWIG_fail;
18443 }
18444 {
18445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18446 }
18447 return resultobj;
18448 fail:
18449 return NULL;
18450 }
18451
18452
18453 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18454 PyObject *resultobj = 0;
18455 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18456 PyObject *arg2 = (PyObject *) 0 ;
18457 bool arg3 = (bool) true ;
18458 void *argp1 = 0 ;
18459 int res1 = 0 ;
18460 bool val3 ;
18461 int ecode3 = 0 ;
18462 PyObject * obj0 = 0 ;
18463 PyObject * obj1 = 0 ;
18464 PyObject * obj2 = 0 ;
18465 char * kwnames[] = {
18466 (char *) "self",(char *) "_self",(char *) "incref", NULL
18467 };
18468
18469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18471 if (!SWIG_IsOK(res1)) {
18472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18473 }
18474 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18475 arg2 = obj1;
18476 if (obj2) {
18477 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18478 if (!SWIG_IsOK(ecode3)) {
18479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18480 }
18481 arg3 = static_cast< bool >(val3);
18482 }
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 resultobj = SWIG_Py_Void();
18490 return resultobj;
18491 fail:
18492 return NULL;
18493 }
18494
18495
18496 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18497 PyObject *obj;
18498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18499 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18500 return SWIG_Py_Void();
18501 }
18502
18503 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18504 return SWIG_Python_InitShadowInstance(args);
18505 }
18506
18507 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18508 PyObject *resultobj = 0;
18509 wxEventType result;
18510
18511 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (wxEventType)wxNewEventType();
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 resultobj = SWIG_From_int(static_cast< int >(result));
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18526 PyObject *resultobj = 0;
18527 wxEvent *arg1 = (wxEvent *) 0 ;
18528 void *argp1 = 0 ;
18529 int res1 = 0 ;
18530 PyObject *swig_obj[1] ;
18531
18532 if (!args) SWIG_fail;
18533 swig_obj[0] = args;
18534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18535 if (!SWIG_IsOK(res1)) {
18536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18537 }
18538 arg1 = reinterpret_cast< wxEvent * >(argp1);
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 delete arg1;
18542
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 resultobj = SWIG_Py_Void();
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18554 PyObject *resultobj = 0;
18555 wxEvent *arg1 = (wxEvent *) 0 ;
18556 wxEventType arg2 ;
18557 void *argp1 = 0 ;
18558 int res1 = 0 ;
18559 int val2 ;
18560 int ecode2 = 0 ;
18561 PyObject * obj0 = 0 ;
18562 PyObject * obj1 = 0 ;
18563 char * kwnames[] = {
18564 (char *) "self",(char *) "typ", NULL
18565 };
18566
18567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18569 if (!SWIG_IsOK(res1)) {
18570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18571 }
18572 arg1 = reinterpret_cast< wxEvent * >(argp1);
18573 ecode2 = SWIG_AsVal_int(obj1, &val2);
18574 if (!SWIG_IsOK(ecode2)) {
18575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18576 }
18577 arg2 = static_cast< wxEventType >(val2);
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 (arg1)->SetEventType(arg2);
18581 wxPyEndAllowThreads(__tstate);
18582 if (PyErr_Occurred()) SWIG_fail;
18583 }
18584 resultobj = SWIG_Py_Void();
18585 return resultobj;
18586 fail:
18587 return NULL;
18588 }
18589
18590
18591 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18592 PyObject *resultobj = 0;
18593 wxEvent *arg1 = (wxEvent *) 0 ;
18594 wxEventType result;
18595 void *argp1 = 0 ;
18596 int res1 = 0 ;
18597 PyObject *swig_obj[1] ;
18598
18599 if (!args) SWIG_fail;
18600 swig_obj[0] = args;
18601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18602 if (!SWIG_IsOK(res1)) {
18603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18604 }
18605 arg1 = reinterpret_cast< wxEvent * >(argp1);
18606 {
18607 PyThreadState* __tstate = wxPyBeginAllowThreads();
18608 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18609 wxPyEndAllowThreads(__tstate);
18610 if (PyErr_Occurred()) SWIG_fail;
18611 }
18612 resultobj = SWIG_From_int(static_cast< int >(result));
18613 return resultobj;
18614 fail:
18615 return NULL;
18616 }
18617
18618
18619 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18620 PyObject *resultobj = 0;
18621 wxEvent *arg1 = (wxEvent *) 0 ;
18622 wxObject *result = 0 ;
18623 void *argp1 = 0 ;
18624 int res1 = 0 ;
18625 PyObject *swig_obj[1] ;
18626
18627 if (!args) SWIG_fail;
18628 swig_obj[0] = args;
18629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18630 if (!SWIG_IsOK(res1)) {
18631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18632 }
18633 arg1 = reinterpret_cast< wxEvent * >(argp1);
18634 {
18635 PyThreadState* __tstate = wxPyBeginAllowThreads();
18636 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18637 wxPyEndAllowThreads(__tstate);
18638 if (PyErr_Occurred()) SWIG_fail;
18639 }
18640 {
18641 resultobj = wxPyMake_wxObject(result, (bool)0);
18642 }
18643 return resultobj;
18644 fail:
18645 return NULL;
18646 }
18647
18648
18649 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18650 PyObject *resultobj = 0;
18651 wxEvent *arg1 = (wxEvent *) 0 ;
18652 wxObject *arg2 = (wxObject *) 0 ;
18653 void *argp1 = 0 ;
18654 int res1 = 0 ;
18655 void *argp2 = 0 ;
18656 int res2 = 0 ;
18657 PyObject * obj0 = 0 ;
18658 PyObject * obj1 = 0 ;
18659 char * kwnames[] = {
18660 (char *) "self",(char *) "obj", NULL
18661 };
18662
18663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18665 if (!SWIG_IsOK(res1)) {
18666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18667 }
18668 arg1 = reinterpret_cast< wxEvent * >(argp1);
18669 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18670 if (!SWIG_IsOK(res2)) {
18671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18672 }
18673 arg2 = reinterpret_cast< wxObject * >(argp2);
18674 {
18675 PyThreadState* __tstate = wxPyBeginAllowThreads();
18676 (arg1)->SetEventObject(arg2);
18677 wxPyEndAllowThreads(__tstate);
18678 if (PyErr_Occurred()) SWIG_fail;
18679 }
18680 resultobj = SWIG_Py_Void();
18681 return resultobj;
18682 fail:
18683 return NULL;
18684 }
18685
18686
18687 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18688 PyObject *resultobj = 0;
18689 wxEvent *arg1 = (wxEvent *) 0 ;
18690 long result;
18691 void *argp1 = 0 ;
18692 int res1 = 0 ;
18693 PyObject *swig_obj[1] ;
18694
18695 if (!args) SWIG_fail;
18696 swig_obj[0] = args;
18697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18698 if (!SWIG_IsOK(res1)) {
18699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18700 }
18701 arg1 = reinterpret_cast< wxEvent * >(argp1);
18702 {
18703 PyThreadState* __tstate = wxPyBeginAllowThreads();
18704 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18705 wxPyEndAllowThreads(__tstate);
18706 if (PyErr_Occurred()) SWIG_fail;
18707 }
18708 resultobj = SWIG_From_long(static_cast< long >(result));
18709 return resultobj;
18710 fail:
18711 return NULL;
18712 }
18713
18714
18715 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18716 PyObject *resultobj = 0;
18717 wxEvent *arg1 = (wxEvent *) 0 ;
18718 long arg2 = (long) 0 ;
18719 void *argp1 = 0 ;
18720 int res1 = 0 ;
18721 long val2 ;
18722 int ecode2 = 0 ;
18723 PyObject * obj0 = 0 ;
18724 PyObject * obj1 = 0 ;
18725 char * kwnames[] = {
18726 (char *) "self",(char *) "ts", NULL
18727 };
18728
18729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18731 if (!SWIG_IsOK(res1)) {
18732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18733 }
18734 arg1 = reinterpret_cast< wxEvent * >(argp1);
18735 if (obj1) {
18736 ecode2 = SWIG_AsVal_long(obj1, &val2);
18737 if (!SWIG_IsOK(ecode2)) {
18738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18739 }
18740 arg2 = static_cast< long >(val2);
18741 }
18742 {
18743 PyThreadState* __tstate = wxPyBeginAllowThreads();
18744 (arg1)->SetTimestamp(arg2);
18745 wxPyEndAllowThreads(__tstate);
18746 if (PyErr_Occurred()) SWIG_fail;
18747 }
18748 resultobj = SWIG_Py_Void();
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18756 PyObject *resultobj = 0;
18757 wxEvent *arg1 = (wxEvent *) 0 ;
18758 int result;
18759 void *argp1 = 0 ;
18760 int res1 = 0 ;
18761 PyObject *swig_obj[1] ;
18762
18763 if (!args) SWIG_fail;
18764 swig_obj[0] = args;
18765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18766 if (!SWIG_IsOK(res1)) {
18767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18768 }
18769 arg1 = reinterpret_cast< wxEvent * >(argp1);
18770 {
18771 PyThreadState* __tstate = wxPyBeginAllowThreads();
18772 result = (int)((wxEvent const *)arg1)->GetId();
18773 wxPyEndAllowThreads(__tstate);
18774 if (PyErr_Occurred()) SWIG_fail;
18775 }
18776 resultobj = SWIG_From_int(static_cast< int >(result));
18777 return resultobj;
18778 fail:
18779 return NULL;
18780 }
18781
18782
18783 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18784 PyObject *resultobj = 0;
18785 wxEvent *arg1 = (wxEvent *) 0 ;
18786 int arg2 ;
18787 void *argp1 = 0 ;
18788 int res1 = 0 ;
18789 int val2 ;
18790 int ecode2 = 0 ;
18791 PyObject * obj0 = 0 ;
18792 PyObject * obj1 = 0 ;
18793 char * kwnames[] = {
18794 (char *) "self",(char *) "Id", NULL
18795 };
18796
18797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18799 if (!SWIG_IsOK(res1)) {
18800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18801 }
18802 arg1 = reinterpret_cast< wxEvent * >(argp1);
18803 ecode2 = SWIG_AsVal_int(obj1, &val2);
18804 if (!SWIG_IsOK(ecode2)) {
18805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18806 }
18807 arg2 = static_cast< int >(val2);
18808 {
18809 PyThreadState* __tstate = wxPyBeginAllowThreads();
18810 (arg1)->SetId(arg2);
18811 wxPyEndAllowThreads(__tstate);
18812 if (PyErr_Occurred()) SWIG_fail;
18813 }
18814 resultobj = SWIG_Py_Void();
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18822 PyObject *resultobj = 0;
18823 wxEvent *arg1 = (wxEvent *) 0 ;
18824 bool result;
18825 void *argp1 = 0 ;
18826 int res1 = 0 ;
18827 PyObject *swig_obj[1] ;
18828
18829 if (!args) SWIG_fail;
18830 swig_obj[0] = args;
18831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18832 if (!SWIG_IsOK(res1)) {
18833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18834 }
18835 arg1 = reinterpret_cast< wxEvent * >(argp1);
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 {
18843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18844 }
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj = 0;
18853 wxEvent *arg1 = (wxEvent *) 0 ;
18854 bool arg2 = (bool) true ;
18855 void *argp1 = 0 ;
18856 int res1 = 0 ;
18857 bool val2 ;
18858 int ecode2 = 0 ;
18859 PyObject * obj0 = 0 ;
18860 PyObject * obj1 = 0 ;
18861 char * kwnames[] = {
18862 (char *) "self",(char *) "skip", NULL
18863 };
18864
18865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18867 if (!SWIG_IsOK(res1)) {
18868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18869 }
18870 arg1 = reinterpret_cast< wxEvent * >(argp1);
18871 if (obj1) {
18872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18873 if (!SWIG_IsOK(ecode2)) {
18874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18875 }
18876 arg2 = static_cast< bool >(val2);
18877 }
18878 {
18879 PyThreadState* __tstate = wxPyBeginAllowThreads();
18880 (arg1)->Skip(arg2);
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 resultobj = SWIG_Py_Void();
18885 return resultobj;
18886 fail:
18887 return NULL;
18888 }
18889
18890
18891 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18892 PyObject *resultobj = 0;
18893 wxEvent *arg1 = (wxEvent *) 0 ;
18894 bool result;
18895 void *argp1 = 0 ;
18896 int res1 = 0 ;
18897 PyObject *swig_obj[1] ;
18898
18899 if (!args) SWIG_fail;
18900 swig_obj[0] = args;
18901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18902 if (!SWIG_IsOK(res1)) {
18903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18904 }
18905 arg1 = reinterpret_cast< wxEvent * >(argp1);
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18909 wxPyEndAllowThreads(__tstate);
18910 if (PyErr_Occurred()) SWIG_fail;
18911 }
18912 {
18913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18914 }
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18922 PyObject *resultobj = 0;
18923 wxEvent *arg1 = (wxEvent *) 0 ;
18924 bool result;
18925 void *argp1 = 0 ;
18926 int res1 = 0 ;
18927 PyObject *swig_obj[1] ;
18928
18929 if (!args) SWIG_fail;
18930 swig_obj[0] = args;
18931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18932 if (!SWIG_IsOK(res1)) {
18933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18934 }
18935 arg1 = reinterpret_cast< wxEvent * >(argp1);
18936 {
18937 PyThreadState* __tstate = wxPyBeginAllowThreads();
18938 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18939 wxPyEndAllowThreads(__tstate);
18940 if (PyErr_Occurred()) SWIG_fail;
18941 }
18942 {
18943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18944 }
18945 return resultobj;
18946 fail:
18947 return NULL;
18948 }
18949
18950
18951 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18952 PyObject *resultobj = 0;
18953 wxEvent *arg1 = (wxEvent *) 0 ;
18954 int result;
18955 void *argp1 = 0 ;
18956 int res1 = 0 ;
18957 PyObject *swig_obj[1] ;
18958
18959 if (!args) SWIG_fail;
18960 swig_obj[0] = args;
18961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18962 if (!SWIG_IsOK(res1)) {
18963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18964 }
18965 arg1 = reinterpret_cast< wxEvent * >(argp1);
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 result = (int)(arg1)->StopPropagation();
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 resultobj = SWIG_From_int(static_cast< int >(result));
18973 return resultobj;
18974 fail:
18975 return NULL;
18976 }
18977
18978
18979 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18980 PyObject *resultobj = 0;
18981 wxEvent *arg1 = (wxEvent *) 0 ;
18982 int arg2 ;
18983 void *argp1 = 0 ;
18984 int res1 = 0 ;
18985 int val2 ;
18986 int ecode2 = 0 ;
18987 PyObject * obj0 = 0 ;
18988 PyObject * obj1 = 0 ;
18989 char * kwnames[] = {
18990 (char *) "self",(char *) "propagationLevel", NULL
18991 };
18992
18993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18995 if (!SWIG_IsOK(res1)) {
18996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18997 }
18998 arg1 = reinterpret_cast< wxEvent * >(argp1);
18999 ecode2 = SWIG_AsVal_int(obj1, &val2);
19000 if (!SWIG_IsOK(ecode2)) {
19001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19002 }
19003 arg2 = static_cast< int >(val2);
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 (arg1)->ResumePropagation(arg2);
19007 wxPyEndAllowThreads(__tstate);
19008 if (PyErr_Occurred()) SWIG_fail;
19009 }
19010 resultobj = SWIG_Py_Void();
19011 return resultobj;
19012 fail:
19013 return NULL;
19014 }
19015
19016
19017 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19018 PyObject *resultobj = 0;
19019 wxEvent *arg1 = (wxEvent *) 0 ;
19020 wxEvent *result = 0 ;
19021 void *argp1 = 0 ;
19022 int res1 = 0 ;
19023 PyObject *swig_obj[1] ;
19024
19025 if (!args) SWIG_fail;
19026 swig_obj[0] = args;
19027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19028 if (!SWIG_IsOK(res1)) {
19029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19030 }
19031 arg1 = reinterpret_cast< wxEvent * >(argp1);
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = (wxEvent *)(arg1)->Clone();
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19039 return resultobj;
19040 fail:
19041 return NULL;
19042 }
19043
19044
19045 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19046 PyObject *obj;
19047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19048 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19049 return SWIG_Py_Void();
19050 }
19051
19052 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19053 PyObject *resultobj = 0;
19054 wxEvent *arg1 = 0 ;
19055 wxPropagationDisabler *result = 0 ;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 char * kwnames[] = {
19060 (char *) "event", NULL
19061 };
19062
19063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19064 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19065 if (!SWIG_IsOK(res1)) {
19066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19067 }
19068 if (!argp1) {
19069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19070 }
19071 arg1 = reinterpret_cast< wxEvent * >(argp1);
19072 {
19073 PyThreadState* __tstate = wxPyBeginAllowThreads();
19074 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19075 wxPyEndAllowThreads(__tstate);
19076 if (PyErr_Occurred()) SWIG_fail;
19077 }
19078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19086 PyObject *resultobj = 0;
19087 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19088 void *argp1 = 0 ;
19089 int res1 = 0 ;
19090 PyObject *swig_obj[1] ;
19091
19092 if (!args) SWIG_fail;
19093 swig_obj[0] = args;
19094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19097 }
19098 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 delete arg1;
19102
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 resultobj = SWIG_Py_Void();
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19114 PyObject *obj;
19115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19116 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19117 return SWIG_Py_Void();
19118 }
19119
19120 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19121 return SWIG_Python_InitShadowInstance(args);
19122 }
19123
19124 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19125 PyObject *resultobj = 0;
19126 wxEvent *arg1 = 0 ;
19127 wxPropagateOnce *result = 0 ;
19128 void *argp1 = 0 ;
19129 int res1 = 0 ;
19130 PyObject * obj0 = 0 ;
19131 char * kwnames[] = {
19132 (char *) "event", NULL
19133 };
19134
19135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19136 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19137 if (!SWIG_IsOK(res1)) {
19138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19139 }
19140 if (!argp1) {
19141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19142 }
19143 arg1 = reinterpret_cast< wxEvent * >(argp1);
19144 {
19145 PyThreadState* __tstate = wxPyBeginAllowThreads();
19146 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19147 wxPyEndAllowThreads(__tstate);
19148 if (PyErr_Occurred()) SWIG_fail;
19149 }
19150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19151 return resultobj;
19152 fail:
19153 return NULL;
19154 }
19155
19156
19157 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19158 PyObject *resultobj = 0;
19159 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19160 void *argp1 = 0 ;
19161 int res1 = 0 ;
19162 PyObject *swig_obj[1] ;
19163
19164 if (!args) SWIG_fail;
19165 swig_obj[0] = args;
19166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19167 if (!SWIG_IsOK(res1)) {
19168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19169 }
19170 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19171 {
19172 PyThreadState* __tstate = wxPyBeginAllowThreads();
19173 delete arg1;
19174
19175 wxPyEndAllowThreads(__tstate);
19176 if (PyErr_Occurred()) SWIG_fail;
19177 }
19178 resultobj = SWIG_Py_Void();
19179 return resultobj;
19180 fail:
19181 return NULL;
19182 }
19183
19184
19185 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19186 PyObject *obj;
19187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19188 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19189 return SWIG_Py_Void();
19190 }
19191
19192 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19193 return SWIG_Python_InitShadowInstance(args);
19194 }
19195
19196 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj = 0;
19198 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19199 int arg2 = (int) 0 ;
19200 wxCommandEvent *result = 0 ;
19201 int val1 ;
19202 int ecode1 = 0 ;
19203 int val2 ;
19204 int ecode2 = 0 ;
19205 PyObject * obj0 = 0 ;
19206 PyObject * obj1 = 0 ;
19207 char * kwnames[] = {
19208 (char *) "commandType",(char *) "winid", NULL
19209 };
19210
19211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19212 if (obj0) {
19213 ecode1 = SWIG_AsVal_int(obj0, &val1);
19214 if (!SWIG_IsOK(ecode1)) {
19215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19216 }
19217 arg1 = static_cast< wxEventType >(val1);
19218 }
19219 if (obj1) {
19220 ecode2 = SWIG_AsVal_int(obj1, &val2);
19221 if (!SWIG_IsOK(ecode2)) {
19222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19223 }
19224 arg2 = static_cast< int >(val2);
19225 }
19226 {
19227 PyThreadState* __tstate = wxPyBeginAllowThreads();
19228 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19229 wxPyEndAllowThreads(__tstate);
19230 if (PyErr_Occurred()) SWIG_fail;
19231 }
19232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19233 return resultobj;
19234 fail:
19235 return NULL;
19236 }
19237
19238
19239 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19240 PyObject *resultobj = 0;
19241 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19242 int result;
19243 void *argp1 = 0 ;
19244 int res1 = 0 ;
19245 PyObject *swig_obj[1] ;
19246
19247 if (!args) SWIG_fail;
19248 swig_obj[0] = args;
19249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19250 if (!SWIG_IsOK(res1)) {
19251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19252 }
19253 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19254 {
19255 PyThreadState* __tstate = wxPyBeginAllowThreads();
19256 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19257 wxPyEndAllowThreads(__tstate);
19258 if (PyErr_Occurred()) SWIG_fail;
19259 }
19260 resultobj = SWIG_From_int(static_cast< int >(result));
19261 return resultobj;
19262 fail:
19263 return NULL;
19264 }
19265
19266
19267 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19268 PyObject *resultobj = 0;
19269 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19270 wxString *arg2 = 0 ;
19271 void *argp1 = 0 ;
19272 int res1 = 0 ;
19273 bool temp2 = false ;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 char * kwnames[] = {
19277 (char *) "self",(char *) "s", NULL
19278 };
19279
19280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19282 if (!SWIG_IsOK(res1)) {
19283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19284 }
19285 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19286 {
19287 arg2 = wxString_in_helper(obj1);
19288 if (arg2 == NULL) SWIG_fail;
19289 temp2 = true;
19290 }
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 (arg1)->SetString((wxString const &)*arg2);
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 resultobj = SWIG_Py_Void();
19298 {
19299 if (temp2)
19300 delete arg2;
19301 }
19302 return resultobj;
19303 fail:
19304 {
19305 if (temp2)
19306 delete arg2;
19307 }
19308 return NULL;
19309 }
19310
19311
19312 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19313 PyObject *resultobj = 0;
19314 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19315 wxString result;
19316 void *argp1 = 0 ;
19317 int res1 = 0 ;
19318 PyObject *swig_obj[1] ;
19319
19320 if (!args) SWIG_fail;
19321 swig_obj[0] = args;
19322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19323 if (!SWIG_IsOK(res1)) {
19324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19325 }
19326 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 result = ((wxCommandEvent const *)arg1)->GetString();
19330 wxPyEndAllowThreads(__tstate);
19331 if (PyErr_Occurred()) SWIG_fail;
19332 }
19333 {
19334 #if wxUSE_UNICODE
19335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19336 #else
19337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19338 #endif
19339 }
19340 return resultobj;
19341 fail:
19342 return NULL;
19343 }
19344
19345
19346 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19347 PyObject *resultobj = 0;
19348 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19349 bool result;
19350 void *argp1 = 0 ;
19351 int res1 = 0 ;
19352 PyObject *swig_obj[1] ;
19353
19354 if (!args) SWIG_fail;
19355 swig_obj[0] = args;
19356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19357 if (!SWIG_IsOK(res1)) {
19358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19359 }
19360 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19361 {
19362 PyThreadState* __tstate = wxPyBeginAllowThreads();
19363 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 {
19368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19369 }
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19377 PyObject *resultobj = 0;
19378 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19379 bool result;
19380 void *argp1 = 0 ;
19381 int res1 = 0 ;
19382 PyObject *swig_obj[1] ;
19383
19384 if (!args) SWIG_fail;
19385 swig_obj[0] = args;
19386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19387 if (!SWIG_IsOK(res1)) {
19388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19389 }
19390 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19391 {
19392 PyThreadState* __tstate = wxPyBeginAllowThreads();
19393 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19394 wxPyEndAllowThreads(__tstate);
19395 if (PyErr_Occurred()) SWIG_fail;
19396 }
19397 {
19398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19399 }
19400 return resultobj;
19401 fail:
19402 return NULL;
19403 }
19404
19405
19406 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19407 PyObject *resultobj = 0;
19408 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19409 long arg2 ;
19410 void *argp1 = 0 ;
19411 int res1 = 0 ;
19412 long val2 ;
19413 int ecode2 = 0 ;
19414 PyObject * obj0 = 0 ;
19415 PyObject * obj1 = 0 ;
19416 char * kwnames[] = {
19417 (char *) "self",(char *) "extraLong", NULL
19418 };
19419
19420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19422 if (!SWIG_IsOK(res1)) {
19423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19424 }
19425 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19426 ecode2 = SWIG_AsVal_long(obj1, &val2);
19427 if (!SWIG_IsOK(ecode2)) {
19428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19429 }
19430 arg2 = static_cast< long >(val2);
19431 {
19432 PyThreadState* __tstate = wxPyBeginAllowThreads();
19433 (arg1)->SetExtraLong(arg2);
19434 wxPyEndAllowThreads(__tstate);
19435 if (PyErr_Occurred()) SWIG_fail;
19436 }
19437 resultobj = SWIG_Py_Void();
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19445 PyObject *resultobj = 0;
19446 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19447 long result;
19448 void *argp1 = 0 ;
19449 int res1 = 0 ;
19450 PyObject *swig_obj[1] ;
19451
19452 if (!args) SWIG_fail;
19453 swig_obj[0] = args;
19454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19455 if (!SWIG_IsOK(res1)) {
19456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19457 }
19458 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19462 wxPyEndAllowThreads(__tstate);
19463 if (PyErr_Occurred()) SWIG_fail;
19464 }
19465 resultobj = SWIG_From_long(static_cast< long >(result));
19466 return resultobj;
19467 fail:
19468 return NULL;
19469 }
19470
19471
19472 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19473 PyObject *resultobj = 0;
19474 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19475 int arg2 ;
19476 void *argp1 = 0 ;
19477 int res1 = 0 ;
19478 int val2 ;
19479 int ecode2 = 0 ;
19480 PyObject * obj0 = 0 ;
19481 PyObject * obj1 = 0 ;
19482 char * kwnames[] = {
19483 (char *) "self",(char *) "i", NULL
19484 };
19485
19486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19488 if (!SWIG_IsOK(res1)) {
19489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19490 }
19491 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19492 ecode2 = SWIG_AsVal_int(obj1, &val2);
19493 if (!SWIG_IsOK(ecode2)) {
19494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19495 }
19496 arg2 = static_cast< int >(val2);
19497 {
19498 PyThreadState* __tstate = wxPyBeginAllowThreads();
19499 (arg1)->SetInt(arg2);
19500 wxPyEndAllowThreads(__tstate);
19501 if (PyErr_Occurred()) SWIG_fail;
19502 }
19503 resultobj = SWIG_Py_Void();
19504 return resultobj;
19505 fail:
19506 return NULL;
19507 }
19508
19509
19510 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19511 PyObject *resultobj = 0;
19512 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19513 int result;
19514 void *argp1 = 0 ;
19515 int res1 = 0 ;
19516 PyObject *swig_obj[1] ;
19517
19518 if (!args) SWIG_fail;
19519 swig_obj[0] = args;
19520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19521 if (!SWIG_IsOK(res1)) {
19522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19523 }
19524 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19525 {
19526 PyThreadState* __tstate = wxPyBeginAllowThreads();
19527 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19528 wxPyEndAllowThreads(__tstate);
19529 if (PyErr_Occurred()) SWIG_fail;
19530 }
19531 resultobj = SWIG_From_int(static_cast< int >(result));
19532 return resultobj;
19533 fail:
19534 return NULL;
19535 }
19536
19537
19538 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19539 PyObject *resultobj = 0;
19540 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19541 PyObject *result = 0 ;
19542 void *argp1 = 0 ;
19543 int res1 = 0 ;
19544 PyObject *swig_obj[1] ;
19545
19546 if (!args) SWIG_fail;
19547 swig_obj[0] = args;
19548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19549 if (!SWIG_IsOK(res1)) {
19550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19551 }
19552 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19553 {
19554 PyThreadState* __tstate = wxPyBeginAllowThreads();
19555 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19556 wxPyEndAllowThreads(__tstate);
19557 if (PyErr_Occurred()) SWIG_fail;
19558 }
19559 resultobj = result;
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj = 0;
19568 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19569 PyObject *arg2 = (PyObject *) 0 ;
19570 void *argp1 = 0 ;
19571 int res1 = 0 ;
19572 PyObject * obj0 = 0 ;
19573 PyObject * obj1 = 0 ;
19574 char * kwnames[] = {
19575 (char *) "self",(char *) "clientData", NULL
19576 };
19577
19578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19580 if (!SWIG_IsOK(res1)) {
19581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19582 }
19583 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19584 arg2 = obj1;
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 wxCommandEvent_SetClientData(arg1,arg2);
19588 wxPyEndAllowThreads(__tstate);
19589 if (PyErr_Occurred()) SWIG_fail;
19590 }
19591 resultobj = SWIG_Py_Void();
19592 return resultobj;
19593 fail:
19594 return NULL;
19595 }
19596
19597
19598 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19599 PyObject *resultobj = 0;
19600 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19601 wxEvent *result = 0 ;
19602 void *argp1 = 0 ;
19603 int res1 = 0 ;
19604 PyObject *swig_obj[1] ;
19605
19606 if (!args) SWIG_fail;
19607 swig_obj[0] = args;
19608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19609 if (!SWIG_IsOK(res1)) {
19610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19611 }
19612 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19627 PyObject *obj;
19628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19629 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19630 return SWIG_Py_Void();
19631 }
19632
19633 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19634 return SWIG_Python_InitShadowInstance(args);
19635 }
19636
19637 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19638 PyObject *resultobj = 0;
19639 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19640 int arg2 = (int) 0 ;
19641 wxNotifyEvent *result = 0 ;
19642 int val1 ;
19643 int ecode1 = 0 ;
19644 int val2 ;
19645 int ecode2 = 0 ;
19646 PyObject * obj0 = 0 ;
19647 PyObject * obj1 = 0 ;
19648 char * kwnames[] = {
19649 (char *) "commandType",(char *) "winid", NULL
19650 };
19651
19652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19653 if (obj0) {
19654 ecode1 = SWIG_AsVal_int(obj0, &val1);
19655 if (!SWIG_IsOK(ecode1)) {
19656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19657 }
19658 arg1 = static_cast< wxEventType >(val1);
19659 }
19660 if (obj1) {
19661 ecode2 = SWIG_AsVal_int(obj1, &val2);
19662 if (!SWIG_IsOK(ecode2)) {
19663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19664 }
19665 arg2 = static_cast< int >(val2);
19666 }
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19681 PyObject *resultobj = 0;
19682 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19683 void *argp1 = 0 ;
19684 int res1 = 0 ;
19685 PyObject *swig_obj[1] ;
19686
19687 if (!args) SWIG_fail;
19688 swig_obj[0] = args;
19689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19690 if (!SWIG_IsOK(res1)) {
19691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19692 }
19693 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19694 {
19695 PyThreadState* __tstate = wxPyBeginAllowThreads();
19696 (arg1)->Veto();
19697 wxPyEndAllowThreads(__tstate);
19698 if (PyErr_Occurred()) SWIG_fail;
19699 }
19700 resultobj = SWIG_Py_Void();
19701 return resultobj;
19702 fail:
19703 return NULL;
19704 }
19705
19706
19707 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19708 PyObject *resultobj = 0;
19709 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19710 void *argp1 = 0 ;
19711 int res1 = 0 ;
19712 PyObject *swig_obj[1] ;
19713
19714 if (!args) SWIG_fail;
19715 swig_obj[0] = args;
19716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19717 if (!SWIG_IsOK(res1)) {
19718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19719 }
19720 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19721 {
19722 PyThreadState* __tstate = wxPyBeginAllowThreads();
19723 (arg1)->Allow();
19724 wxPyEndAllowThreads(__tstate);
19725 if (PyErr_Occurred()) SWIG_fail;
19726 }
19727 resultobj = SWIG_Py_Void();
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19735 PyObject *resultobj = 0;
19736 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19737 bool result;
19738 void *argp1 = 0 ;
19739 int res1 = 0 ;
19740 PyObject *swig_obj[1] ;
19741
19742 if (!args) SWIG_fail;
19743 swig_obj[0] = args;
19744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19745 if (!SWIG_IsOK(res1)) {
19746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19747 }
19748 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19749 {
19750 PyThreadState* __tstate = wxPyBeginAllowThreads();
19751 result = (bool)(arg1)->IsAllowed();
19752 wxPyEndAllowThreads(__tstate);
19753 if (PyErr_Occurred()) SWIG_fail;
19754 }
19755 {
19756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19757 }
19758 return resultobj;
19759 fail:
19760 return NULL;
19761 }
19762
19763
19764 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19765 PyObject *obj;
19766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19767 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19768 return SWIG_Py_Void();
19769 }
19770
19771 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19772 return SWIG_Python_InitShadowInstance(args);
19773 }
19774
19775 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj = 0;
19777 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19778 int arg2 = (int) 0 ;
19779 int arg3 = (int) 0 ;
19780 int arg4 = (int) 0 ;
19781 wxScrollEvent *result = 0 ;
19782 int val1 ;
19783 int ecode1 = 0 ;
19784 int val2 ;
19785 int ecode2 = 0 ;
19786 int val3 ;
19787 int ecode3 = 0 ;
19788 int val4 ;
19789 int ecode4 = 0 ;
19790 PyObject * obj0 = 0 ;
19791 PyObject * obj1 = 0 ;
19792 PyObject * obj2 = 0 ;
19793 PyObject * obj3 = 0 ;
19794 char * kwnames[] = {
19795 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19796 };
19797
19798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19799 if (obj0) {
19800 ecode1 = SWIG_AsVal_int(obj0, &val1);
19801 if (!SWIG_IsOK(ecode1)) {
19802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19803 }
19804 arg1 = static_cast< wxEventType >(val1);
19805 }
19806 if (obj1) {
19807 ecode2 = SWIG_AsVal_int(obj1, &val2);
19808 if (!SWIG_IsOK(ecode2)) {
19809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19810 }
19811 arg2 = static_cast< int >(val2);
19812 }
19813 if (obj2) {
19814 ecode3 = SWIG_AsVal_int(obj2, &val3);
19815 if (!SWIG_IsOK(ecode3)) {
19816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19817 }
19818 arg3 = static_cast< int >(val3);
19819 }
19820 if (obj3) {
19821 ecode4 = SWIG_AsVal_int(obj3, &val4);
19822 if (!SWIG_IsOK(ecode4)) {
19823 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19824 }
19825 arg4 = static_cast< int >(val4);
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19834 return resultobj;
19835 fail:
19836 return NULL;
19837 }
19838
19839
19840 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19841 PyObject *resultobj = 0;
19842 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19843 int result;
19844 void *argp1 = 0 ;
19845 int res1 = 0 ;
19846 PyObject *swig_obj[1] ;
19847
19848 if (!args) SWIG_fail;
19849 swig_obj[0] = args;
19850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19851 if (!SWIG_IsOK(res1)) {
19852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19853 }
19854 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 resultobj = SWIG_From_int(static_cast< int >(result));
19862 return resultobj;
19863 fail:
19864 return NULL;
19865 }
19866
19867
19868 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19869 PyObject *resultobj = 0;
19870 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19871 int result;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 PyObject *swig_obj[1] ;
19875
19876 if (!args) SWIG_fail;
19877 swig_obj[0] = args;
19878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19879 if (!SWIG_IsOK(res1)) {
19880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19881 }
19882 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19883 {
19884 PyThreadState* __tstate = wxPyBeginAllowThreads();
19885 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 resultobj = SWIG_From_int(static_cast< int >(result));
19890 return resultobj;
19891 fail:
19892 return NULL;
19893 }
19894
19895
19896 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19897 PyObject *resultobj = 0;
19898 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19899 int arg2 ;
19900 void *argp1 = 0 ;
19901 int res1 = 0 ;
19902 int val2 ;
19903 int ecode2 = 0 ;
19904 PyObject * obj0 = 0 ;
19905 PyObject * obj1 = 0 ;
19906 char * kwnames[] = {
19907 (char *) "self",(char *) "orient", NULL
19908 };
19909
19910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19912 if (!SWIG_IsOK(res1)) {
19913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19914 }
19915 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19916 ecode2 = SWIG_AsVal_int(obj1, &val2);
19917 if (!SWIG_IsOK(ecode2)) {
19918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19919 }
19920 arg2 = static_cast< int >(val2);
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 (arg1)->SetOrientation(arg2);
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 resultobj = SWIG_Py_Void();
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj = 0;
19936 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19937 int arg2 ;
19938 void *argp1 = 0 ;
19939 int res1 = 0 ;
19940 int val2 ;
19941 int ecode2 = 0 ;
19942 PyObject * obj0 = 0 ;
19943 PyObject * obj1 = 0 ;
19944 char * kwnames[] = {
19945 (char *) "self",(char *) "pos", NULL
19946 };
19947
19948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19950 if (!SWIG_IsOK(res1)) {
19951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19952 }
19953 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19954 ecode2 = SWIG_AsVal_int(obj1, &val2);
19955 if (!SWIG_IsOK(ecode2)) {
19956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19957 }
19958 arg2 = static_cast< int >(val2);
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 (arg1)->SetPosition(arg2);
19962 wxPyEndAllowThreads(__tstate);
19963 if (PyErr_Occurred()) SWIG_fail;
19964 }
19965 resultobj = SWIG_Py_Void();
19966 return resultobj;
19967 fail:
19968 return NULL;
19969 }
19970
19971
19972 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19973 PyObject *obj;
19974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19975 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19976 return SWIG_Py_Void();
19977 }
19978
19979 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19980 return SWIG_Python_InitShadowInstance(args);
19981 }
19982
19983 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19984 PyObject *resultobj = 0;
19985 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19986 int arg2 = (int) 0 ;
19987 int arg3 = (int) 0 ;
19988 wxScrollWinEvent *result = 0 ;
19989 int val1 ;
19990 int ecode1 = 0 ;
19991 int val2 ;
19992 int ecode2 = 0 ;
19993 int val3 ;
19994 int ecode3 = 0 ;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 PyObject * obj2 = 0 ;
19998 char * kwnames[] = {
19999 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20000 };
20001
20002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20003 if (obj0) {
20004 ecode1 = SWIG_AsVal_int(obj0, &val1);
20005 if (!SWIG_IsOK(ecode1)) {
20006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20007 }
20008 arg1 = static_cast< wxEventType >(val1);
20009 }
20010 if (obj1) {
20011 ecode2 = SWIG_AsVal_int(obj1, &val2);
20012 if (!SWIG_IsOK(ecode2)) {
20013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20014 }
20015 arg2 = static_cast< int >(val2);
20016 }
20017 if (obj2) {
20018 ecode3 = SWIG_AsVal_int(obj2, &val3);
20019 if (!SWIG_IsOK(ecode3)) {
20020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20021 }
20022 arg3 = static_cast< int >(val3);
20023 }
20024 {
20025 PyThreadState* __tstate = wxPyBeginAllowThreads();
20026 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20027 wxPyEndAllowThreads(__tstate);
20028 if (PyErr_Occurred()) SWIG_fail;
20029 }
20030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20031 return resultobj;
20032 fail:
20033 return NULL;
20034 }
20035
20036
20037 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20038 PyObject *resultobj = 0;
20039 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20040 int result;
20041 void *argp1 = 0 ;
20042 int res1 = 0 ;
20043 PyObject *swig_obj[1] ;
20044
20045 if (!args) SWIG_fail;
20046 swig_obj[0] = args;
20047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20048 if (!SWIG_IsOK(res1)) {
20049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20050 }
20051 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20052 {
20053 PyThreadState* __tstate = wxPyBeginAllowThreads();
20054 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20055 wxPyEndAllowThreads(__tstate);
20056 if (PyErr_Occurred()) SWIG_fail;
20057 }
20058 resultobj = SWIG_From_int(static_cast< int >(result));
20059 return resultobj;
20060 fail:
20061 return NULL;
20062 }
20063
20064
20065 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20066 PyObject *resultobj = 0;
20067 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20068 int result;
20069 void *argp1 = 0 ;
20070 int res1 = 0 ;
20071 PyObject *swig_obj[1] ;
20072
20073 if (!args) SWIG_fail;
20074 swig_obj[0] = args;
20075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20076 if (!SWIG_IsOK(res1)) {
20077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20078 }
20079 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20080 {
20081 PyThreadState* __tstate = wxPyBeginAllowThreads();
20082 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20083 wxPyEndAllowThreads(__tstate);
20084 if (PyErr_Occurred()) SWIG_fail;
20085 }
20086 resultobj = SWIG_From_int(static_cast< int >(result));
20087 return resultobj;
20088 fail:
20089 return NULL;
20090 }
20091
20092
20093 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20094 PyObject *resultobj = 0;
20095 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20096 int arg2 ;
20097 void *argp1 = 0 ;
20098 int res1 = 0 ;
20099 int val2 ;
20100 int ecode2 = 0 ;
20101 PyObject * obj0 = 0 ;
20102 PyObject * obj1 = 0 ;
20103 char * kwnames[] = {
20104 (char *) "self",(char *) "orient", NULL
20105 };
20106
20107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20109 if (!SWIG_IsOK(res1)) {
20110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20111 }
20112 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20113 ecode2 = SWIG_AsVal_int(obj1, &val2);
20114 if (!SWIG_IsOK(ecode2)) {
20115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20116 }
20117 arg2 = static_cast< int >(val2);
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 (arg1)->SetOrientation(arg2);
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 resultobj = SWIG_Py_Void();
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20132 PyObject *resultobj = 0;
20133 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20134 int arg2 ;
20135 void *argp1 = 0 ;
20136 int res1 = 0 ;
20137 int val2 ;
20138 int ecode2 = 0 ;
20139 PyObject * obj0 = 0 ;
20140 PyObject * obj1 = 0 ;
20141 char * kwnames[] = {
20142 (char *) "self",(char *) "pos", NULL
20143 };
20144
20145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20147 if (!SWIG_IsOK(res1)) {
20148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20149 }
20150 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20151 ecode2 = SWIG_AsVal_int(obj1, &val2);
20152 if (!SWIG_IsOK(ecode2)) {
20153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20154 }
20155 arg2 = static_cast< int >(val2);
20156 {
20157 PyThreadState* __tstate = wxPyBeginAllowThreads();
20158 (arg1)->SetPosition(arg2);
20159 wxPyEndAllowThreads(__tstate);
20160 if (PyErr_Occurred()) SWIG_fail;
20161 }
20162 resultobj = SWIG_Py_Void();
20163 return resultobj;
20164 fail:
20165 return NULL;
20166 }
20167
20168
20169 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20170 PyObject *obj;
20171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20172 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20173 return SWIG_Py_Void();
20174 }
20175
20176 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 return SWIG_Python_InitShadowInstance(args);
20178 }
20179
20180 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20181 PyObject *resultobj = 0;
20182 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20183 wxMouseEvent *result = 0 ;
20184 int val1 ;
20185 int ecode1 = 0 ;
20186 PyObject * obj0 = 0 ;
20187 char * kwnames[] = {
20188 (char *) "mouseType", NULL
20189 };
20190
20191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20192 if (obj0) {
20193 ecode1 = SWIG_AsVal_int(obj0, &val1);
20194 if (!SWIG_IsOK(ecode1)) {
20195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20196 }
20197 arg1 = static_cast< wxEventType >(val1);
20198 }
20199 {
20200 PyThreadState* __tstate = wxPyBeginAllowThreads();
20201 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 {
20206 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20207 }
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20215 PyObject *resultobj = 0;
20216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20217 bool result;
20218 void *argp1 = 0 ;
20219 int res1 = 0 ;
20220 PyObject *swig_obj[1] ;
20221
20222 if (!args) SWIG_fail;
20223 swig_obj[0] = args;
20224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20225 if (!SWIG_IsOK(res1)) {
20226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20227 }
20228 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20232 wxPyEndAllowThreads(__tstate);
20233 if (PyErr_Occurred()) SWIG_fail;
20234 }
20235 {
20236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20237 }
20238 return resultobj;
20239 fail:
20240 return NULL;
20241 }
20242
20243
20244 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20245 PyObject *resultobj = 0;
20246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20247 int arg2 = (int) wxMOUSE_BTN_ANY ;
20248 bool result;
20249 void *argp1 = 0 ;
20250 int res1 = 0 ;
20251 int val2 ;
20252 int ecode2 = 0 ;
20253 PyObject * obj0 = 0 ;
20254 PyObject * obj1 = 0 ;
20255 char * kwnames[] = {
20256 (char *) "self",(char *) "but", NULL
20257 };
20258
20259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20261 if (!SWIG_IsOK(res1)) {
20262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20263 }
20264 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20265 if (obj1) {
20266 ecode2 = SWIG_AsVal_int(obj1, &val2);
20267 if (!SWIG_IsOK(ecode2)) {
20268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20269 }
20270 arg2 = static_cast< int >(val2);
20271 }
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20275 wxPyEndAllowThreads(__tstate);
20276 if (PyErr_Occurred()) SWIG_fail;
20277 }
20278 {
20279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20280 }
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj = 0;
20289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20290 int arg2 = (int) wxMOUSE_BTN_ANY ;
20291 bool result;
20292 void *argp1 = 0 ;
20293 int res1 = 0 ;
20294 int val2 ;
20295 int ecode2 = 0 ;
20296 PyObject * obj0 = 0 ;
20297 PyObject * obj1 = 0 ;
20298 char * kwnames[] = {
20299 (char *) "self",(char *) "but", NULL
20300 };
20301
20302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20304 if (!SWIG_IsOK(res1)) {
20305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20306 }
20307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20308 if (obj1) {
20309 ecode2 = SWIG_AsVal_int(obj1, &val2);
20310 if (!SWIG_IsOK(ecode2)) {
20311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20312 }
20313 arg2 = static_cast< int >(val2);
20314 }
20315 {
20316 PyThreadState* __tstate = wxPyBeginAllowThreads();
20317 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 {
20322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20323 }
20324 return resultobj;
20325 fail:
20326 return NULL;
20327 }
20328
20329
20330 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20331 PyObject *resultobj = 0;
20332 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20333 int arg2 = (int) wxMOUSE_BTN_ANY ;
20334 bool result;
20335 void *argp1 = 0 ;
20336 int res1 = 0 ;
20337 int val2 ;
20338 int ecode2 = 0 ;
20339 PyObject * obj0 = 0 ;
20340 PyObject * obj1 = 0 ;
20341 char * kwnames[] = {
20342 (char *) "self",(char *) "but", NULL
20343 };
20344
20345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20347 if (!SWIG_IsOK(res1)) {
20348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20349 }
20350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20351 if (obj1) {
20352 ecode2 = SWIG_AsVal_int(obj1, &val2);
20353 if (!SWIG_IsOK(ecode2)) {
20354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20355 }
20356 arg2 = static_cast< int >(val2);
20357 }
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 {
20365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20366 }
20367 return resultobj;
20368 fail:
20369 return NULL;
20370 }
20371
20372
20373 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20374 PyObject *resultobj = 0;
20375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20376 int arg2 ;
20377 bool result;
20378 void *argp1 = 0 ;
20379 int res1 = 0 ;
20380 int val2 ;
20381 int ecode2 = 0 ;
20382 PyObject * obj0 = 0 ;
20383 PyObject * obj1 = 0 ;
20384 char * kwnames[] = {
20385 (char *) "self",(char *) "button", NULL
20386 };
20387
20388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20390 if (!SWIG_IsOK(res1)) {
20391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20392 }
20393 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20394 ecode2 = SWIG_AsVal_int(obj1, &val2);
20395 if (!SWIG_IsOK(ecode2)) {
20396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20397 }
20398 arg2 = static_cast< int >(val2);
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 {
20406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20407 }
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj = 0;
20416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20417 int arg2 ;
20418 bool result;
20419 void *argp1 = 0 ;
20420 int res1 = 0 ;
20421 int val2 ;
20422 int ecode2 = 0 ;
20423 PyObject * obj0 = 0 ;
20424 PyObject * obj1 = 0 ;
20425 char * kwnames[] = {
20426 (char *) "self",(char *) "but", NULL
20427 };
20428
20429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20431 if (!SWIG_IsOK(res1)) {
20432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20433 }
20434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20435 ecode2 = SWIG_AsVal_int(obj1, &val2);
20436 if (!SWIG_IsOK(ecode2)) {
20437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20438 }
20439 arg2 = static_cast< int >(val2);
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20443 wxPyEndAllowThreads(__tstate);
20444 if (PyErr_Occurred()) SWIG_fail;
20445 }
20446 {
20447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20448 }
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20456 PyObject *resultobj = 0;
20457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20458 int result;
20459 void *argp1 = 0 ;
20460 int res1 = 0 ;
20461 PyObject *swig_obj[1] ;
20462
20463 if (!args) SWIG_fail;
20464 swig_obj[0] = args;
20465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20466 if (!SWIG_IsOK(res1)) {
20467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20468 }
20469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20470 {
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20473 wxPyEndAllowThreads(__tstate);
20474 if (PyErr_Occurred()) SWIG_fail;
20475 }
20476 resultobj = SWIG_From_int(static_cast< int >(result));
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20484 PyObject *resultobj = 0;
20485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20486 bool result;
20487 void *argp1 = 0 ;
20488 int res1 = 0 ;
20489 PyObject *swig_obj[1] ;
20490
20491 if (!args) SWIG_fail;
20492 swig_obj[0] = args;
20493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20494 if (!SWIG_IsOK(res1)) {
20495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20496 }
20497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20506 }
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20514 PyObject *resultobj = 0;
20515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20516 bool result;
20517 void *argp1 = 0 ;
20518 int res1 = 0 ;
20519 PyObject *swig_obj[1] ;
20520
20521 if (!args) SWIG_fail;
20522 swig_obj[0] = args;
20523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20524 if (!SWIG_IsOK(res1)) {
20525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20526 }
20527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20536 }
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 PyObject *resultobj = 0;
20545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20546 bool result;
20547 void *argp1 = 0 ;
20548 int res1 = 0 ;
20549 PyObject *swig_obj[1] ;
20550
20551 if (!args) SWIG_fail;
20552 swig_obj[0] = args;
20553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20554 if (!SWIG_IsOK(res1)) {
20555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20556 }
20557 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 {
20565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20574 PyObject *resultobj = 0;
20575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20576 bool result;
20577 void *argp1 = 0 ;
20578 int res1 = 0 ;
20579 PyObject *swig_obj[1] ;
20580
20581 if (!args) SWIG_fail;
20582 swig_obj[0] = args;
20583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20586 }
20587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 {
20595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20596 }
20597 return resultobj;
20598 fail:
20599 return NULL;
20600 }
20601
20602
20603 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20604 PyObject *resultobj = 0;
20605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20606 bool result;
20607 void *argp1 = 0 ;
20608 int res1 = 0 ;
20609 PyObject *swig_obj[1] ;
20610
20611 if (!args) SWIG_fail;
20612 swig_obj[0] = args;
20613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20614 if (!SWIG_IsOK(res1)) {
20615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20616 }
20617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20621 wxPyEndAllowThreads(__tstate);
20622 if (PyErr_Occurred()) SWIG_fail;
20623 }
20624 {
20625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20626 }
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20634 PyObject *resultobj = 0;
20635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20636 bool result;
20637 void *argp1 = 0 ;
20638 int res1 = 0 ;
20639 PyObject *swig_obj[1] ;
20640
20641 if (!args) SWIG_fail;
20642 swig_obj[0] = args;
20643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20644 if (!SWIG_IsOK(res1)) {
20645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20646 }
20647 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20651 wxPyEndAllowThreads(__tstate);
20652 if (PyErr_Occurred()) SWIG_fail;
20653 }
20654 {
20655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20656 }
20657 return resultobj;
20658 fail:
20659 return NULL;
20660 }
20661
20662
20663 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20664 PyObject *resultobj = 0;
20665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20666 bool result;
20667 void *argp1 = 0 ;
20668 int res1 = 0 ;
20669 PyObject *swig_obj[1] ;
20670
20671 if (!args) SWIG_fail;
20672 swig_obj[0] = args;
20673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20676 }
20677 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 {
20685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20686 }
20687 return resultobj;
20688 fail:
20689 return NULL;
20690 }
20691
20692
20693 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20694 PyObject *resultobj = 0;
20695 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20696 bool result;
20697 void *argp1 = 0 ;
20698 int res1 = 0 ;
20699 PyObject *swig_obj[1] ;
20700
20701 if (!args) SWIG_fail;
20702 swig_obj[0] = args;
20703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20704 if (!SWIG_IsOK(res1)) {
20705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20706 }
20707 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20711 wxPyEndAllowThreads(__tstate);
20712 if (PyErr_Occurred()) SWIG_fail;
20713 }
20714 {
20715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20716 }
20717 return resultobj;
20718 fail:
20719 return NULL;
20720 }
20721
20722
20723 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20724 PyObject *resultobj = 0;
20725 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20726 bool result;
20727 void *argp1 = 0 ;
20728 int res1 = 0 ;
20729 PyObject *swig_obj[1] ;
20730
20731 if (!args) SWIG_fail;
20732 swig_obj[0] = args;
20733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20734 if (!SWIG_IsOK(res1)) {
20735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20736 }
20737 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20738 {
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20741 wxPyEndAllowThreads(__tstate);
20742 if (PyErr_Occurred()) SWIG_fail;
20743 }
20744 {
20745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20746 }
20747 return resultobj;
20748 fail:
20749 return NULL;
20750 }
20751
20752
20753 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20754 PyObject *resultobj = 0;
20755 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20756 bool result;
20757 void *argp1 = 0 ;
20758 int res1 = 0 ;
20759 PyObject *swig_obj[1] ;
20760
20761 if (!args) SWIG_fail;
20762 swig_obj[0] = args;
20763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20764 if (!SWIG_IsOK(res1)) {
20765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20766 }
20767 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20768 {
20769 PyThreadState* __tstate = wxPyBeginAllowThreads();
20770 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20771 wxPyEndAllowThreads(__tstate);
20772 if (PyErr_Occurred()) SWIG_fail;
20773 }
20774 {
20775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20776 }
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20784 PyObject *resultobj = 0;
20785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20786 bool result;
20787 void *argp1 = 0 ;
20788 int res1 = 0 ;
20789 PyObject *swig_obj[1] ;
20790
20791 if (!args) SWIG_fail;
20792 swig_obj[0] = args;
20793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20794 if (!SWIG_IsOK(res1)) {
20795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20796 }
20797 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 {
20805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20806 }
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20814 PyObject *resultobj = 0;
20815 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20816 bool result;
20817 void *argp1 = 0 ;
20818 int res1 = 0 ;
20819 PyObject *swig_obj[1] ;
20820
20821 if (!args) SWIG_fail;
20822 swig_obj[0] = args;
20823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20824 if (!SWIG_IsOK(res1)) {
20825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20826 }
20827 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20831 wxPyEndAllowThreads(__tstate);
20832 if (PyErr_Occurred()) SWIG_fail;
20833 }
20834 {
20835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20836 }
20837 return resultobj;
20838 fail:
20839 return NULL;
20840 }
20841
20842
20843 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20844 PyObject *resultobj = 0;
20845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20846 bool result;
20847 void *argp1 = 0 ;
20848 int res1 = 0 ;
20849 PyObject *swig_obj[1] ;
20850
20851 if (!args) SWIG_fail;
20852 swig_obj[0] = args;
20853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20854 if (!SWIG_IsOK(res1)) {
20855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20856 }
20857 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 {
20865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20866 }
20867 return resultobj;
20868 fail:
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20874 PyObject *resultobj = 0;
20875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20876 bool result;
20877 void *argp1 = 0 ;
20878 int res1 = 0 ;
20879 PyObject *swig_obj[1] ;
20880
20881 if (!args) SWIG_fail;
20882 swig_obj[0] = args;
20883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20884 if (!SWIG_IsOK(res1)) {
20885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20886 }
20887 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 {
20895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20896 }
20897 return resultobj;
20898 fail:
20899 return NULL;
20900 }
20901
20902
20903 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20904 PyObject *resultobj = 0;
20905 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20906 bool result;
20907 void *argp1 = 0 ;
20908 int res1 = 0 ;
20909 PyObject *swig_obj[1] ;
20910
20911 if (!args) SWIG_fail;
20912 swig_obj[0] = args;
20913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20914 if (!SWIG_IsOK(res1)) {
20915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20916 }
20917 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20918 {
20919 PyThreadState* __tstate = wxPyBeginAllowThreads();
20920 result = (bool)(arg1)->LeftIsDown();
20921 wxPyEndAllowThreads(__tstate);
20922 if (PyErr_Occurred()) SWIG_fail;
20923 }
20924 {
20925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20926 }
20927 return resultobj;
20928 fail:
20929 return NULL;
20930 }
20931
20932
20933 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20934 PyObject *resultobj = 0;
20935 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20936 bool result;
20937 void *argp1 = 0 ;
20938 int res1 = 0 ;
20939 PyObject *swig_obj[1] ;
20940
20941 if (!args) SWIG_fail;
20942 swig_obj[0] = args;
20943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20944 if (!SWIG_IsOK(res1)) {
20945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20946 }
20947 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (bool)(arg1)->MiddleIsDown();
20951 wxPyEndAllowThreads(__tstate);
20952 if (PyErr_Occurred()) SWIG_fail;
20953 }
20954 {
20955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20956 }
20957 return resultobj;
20958 fail:
20959 return NULL;
20960 }
20961
20962
20963 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20964 PyObject *resultobj = 0;
20965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20966 bool result;
20967 void *argp1 = 0 ;
20968 int res1 = 0 ;
20969 PyObject *swig_obj[1] ;
20970
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_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20976 }
20977 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 result = (bool)(arg1)->RightIsDown();
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 {
20985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20986 }
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20994 PyObject *resultobj = 0;
20995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20996 bool result;
20997 void *argp1 = 0 ;
20998 int res1 = 0 ;
20999 PyObject *swig_obj[1] ;
21000
21001 if (!args) SWIG_fail;
21002 swig_obj[0] = args;
21003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21004 if (!SWIG_IsOK(res1)) {
21005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21006 }
21007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21008 {
21009 PyThreadState* __tstate = wxPyBeginAllowThreads();
21010 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21011 wxPyEndAllowThreads(__tstate);
21012 if (PyErr_Occurred()) SWIG_fail;
21013 }
21014 {
21015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21016 }
21017 return resultobj;
21018 fail:
21019 return NULL;
21020 }
21021
21022
21023 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21024 PyObject *resultobj = 0;
21025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21026 bool result;
21027 void *argp1 = 0 ;
21028 int res1 = 0 ;
21029 PyObject *swig_obj[1] ;
21030
21031 if (!args) SWIG_fail;
21032 swig_obj[0] = args;
21033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21034 if (!SWIG_IsOK(res1)) {
21035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21036 }
21037 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21041 wxPyEndAllowThreads(__tstate);
21042 if (PyErr_Occurred()) SWIG_fail;
21043 }
21044 {
21045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21046 }
21047 return resultobj;
21048 fail:
21049 return NULL;
21050 }
21051
21052
21053 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21054 PyObject *resultobj = 0;
21055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21056 bool result;
21057 void *argp1 = 0 ;
21058 int res1 = 0 ;
21059 PyObject *swig_obj[1] ;
21060
21061 if (!args) SWIG_fail;
21062 swig_obj[0] = args;
21063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21064 if (!SWIG_IsOK(res1)) {
21065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21066 }
21067 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 {
21075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21076 }
21077 return resultobj;
21078 fail:
21079 return NULL;
21080 }
21081
21082
21083 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21084 PyObject *resultobj = 0;
21085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21086 bool result;
21087 void *argp1 = 0 ;
21088 int res1 = 0 ;
21089 PyObject *swig_obj[1] ;
21090
21091 if (!args) SWIG_fail;
21092 swig_obj[0] = args;
21093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21096 }
21097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21098 {
21099 PyThreadState* __tstate = wxPyBeginAllowThreads();
21100 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 {
21105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21106 }
21107 return resultobj;
21108 fail:
21109 return NULL;
21110 }
21111
21112
21113 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21114 PyObject *resultobj = 0;
21115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21116 wxPoint result;
21117 void *argp1 = 0 ;
21118 int res1 = 0 ;
21119 PyObject *swig_obj[1] ;
21120
21121 if (!args) SWIG_fail;
21122 swig_obj[0] = args;
21123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21124 if (!SWIG_IsOK(res1)) {
21125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21126 }
21127 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21128 {
21129 PyThreadState* __tstate = wxPyBeginAllowThreads();
21130 result = (arg1)->GetPosition();
21131 wxPyEndAllowThreads(__tstate);
21132 if (PyErr_Occurred()) SWIG_fail;
21133 }
21134 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21142 PyObject *resultobj = 0;
21143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21144 long *arg2 = (long *) 0 ;
21145 long *arg3 = (long *) 0 ;
21146 void *argp1 = 0 ;
21147 int res1 = 0 ;
21148 long temp2 ;
21149 int res2 = SWIG_TMPOBJ ;
21150 long temp3 ;
21151 int res3 = SWIG_TMPOBJ ;
21152 PyObject *swig_obj[1] ;
21153
21154 arg2 = &temp2;
21155 arg3 = &temp3;
21156 if (!args) SWIG_fail;
21157 swig_obj[0] = args;
21158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21159 if (!SWIG_IsOK(res1)) {
21160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21161 }
21162 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21163 {
21164 PyThreadState* __tstate = wxPyBeginAllowThreads();
21165 (arg1)->GetPosition(arg2,arg3);
21166 wxPyEndAllowThreads(__tstate);
21167 if (PyErr_Occurred()) SWIG_fail;
21168 }
21169 resultobj = SWIG_Py_Void();
21170 if (SWIG_IsTmpObj(res2)) {
21171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21172 } else {
21173 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21175 }
21176 if (SWIG_IsTmpObj(res3)) {
21177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21178 } else {
21179 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21181 }
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj = 0;
21190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21191 wxDC *arg2 = 0 ;
21192 wxPoint result;
21193 void *argp1 = 0 ;
21194 int res1 = 0 ;
21195 void *argp2 = 0 ;
21196 int res2 = 0 ;
21197 PyObject * obj0 = 0 ;
21198 PyObject * obj1 = 0 ;
21199 char * kwnames[] = {
21200 (char *) "self",(char *) "dc", NULL
21201 };
21202
21203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21205 if (!SWIG_IsOK(res1)) {
21206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21207 }
21208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21209 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21210 if (!SWIG_IsOK(res2)) {
21211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21212 }
21213 if (!argp2) {
21214 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21215 }
21216 arg2 = reinterpret_cast< wxDC * >(argp2);
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21233 int result;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21243 }
21244 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (int)((wxMouseEvent const *)arg1)->GetX();
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 resultobj = SWIG_From_int(static_cast< int >(result));
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21259 PyObject *resultobj = 0;
21260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21261 int result;
21262 void *argp1 = 0 ;
21263 int res1 = 0 ;
21264 PyObject *swig_obj[1] ;
21265
21266 if (!args) SWIG_fail;
21267 swig_obj[0] = args;
21268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (int)((wxMouseEvent const *)arg1)->GetY();
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 resultobj = SWIG_From_int(static_cast< int >(result));
21280 return resultobj;
21281 fail:
21282 return NULL;
21283 }
21284
21285
21286 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21287 PyObject *resultobj = 0;
21288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21289 int result;
21290 void *argp1 = 0 ;
21291 int res1 = 0 ;
21292 PyObject *swig_obj[1] ;
21293
21294 if (!args) SWIG_fail;
21295 swig_obj[0] = args;
21296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21297 if (!SWIG_IsOK(res1)) {
21298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21299 }
21300 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21301 {
21302 PyThreadState* __tstate = wxPyBeginAllowThreads();
21303 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 resultobj = SWIG_From_int(static_cast< int >(result));
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21317 int result;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 PyObject *swig_obj[1] ;
21321
21322 if (!args) SWIG_fail;
21323 swig_obj[0] = args;
21324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21327 }
21328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21329 {
21330 PyThreadState* __tstate = wxPyBeginAllowThreads();
21331 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21332 wxPyEndAllowThreads(__tstate);
21333 if (PyErr_Occurred()) SWIG_fail;
21334 }
21335 resultobj = SWIG_From_int(static_cast< int >(result));
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21343 PyObject *resultobj = 0;
21344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21345 int result;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 PyObject *swig_obj[1] ;
21349
21350 if (!args) SWIG_fail;
21351 swig_obj[0] = args;
21352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21353 if (!SWIG_IsOK(res1)) {
21354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21355 }
21356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21357 {
21358 PyThreadState* __tstate = wxPyBeginAllowThreads();
21359 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21360 wxPyEndAllowThreads(__tstate);
21361 if (PyErr_Occurred()) SWIG_fail;
21362 }
21363 resultobj = SWIG_From_int(static_cast< int >(result));
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21371 PyObject *resultobj = 0;
21372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21373 bool result;
21374 void *argp1 = 0 ;
21375 int res1 = 0 ;
21376 PyObject *swig_obj[1] ;
21377
21378 if (!args) SWIG_fail;
21379 swig_obj[0] = args;
21380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21381 if (!SWIG_IsOK(res1)) {
21382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21383 }
21384 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21385 {
21386 PyThreadState* __tstate = wxPyBeginAllowThreads();
21387 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21388 wxPyEndAllowThreads(__tstate);
21389 if (PyErr_Occurred()) SWIG_fail;
21390 }
21391 {
21392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21393 }
21394 return resultobj;
21395 fail:
21396 return NULL;
21397 }
21398
21399
21400 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21401 PyObject *resultobj = 0;
21402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21403 int arg2 ;
21404 void *argp1 = 0 ;
21405 int res1 = 0 ;
21406 int val2 ;
21407 int ecode2 = 0 ;
21408 PyObject *swig_obj[2] ;
21409
21410 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21412 if (!SWIG_IsOK(res1)) {
21413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21414 }
21415 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21416 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21417 if (!SWIG_IsOK(ecode2)) {
21418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21419 }
21420 arg2 = static_cast< int >(val2);
21421 if (arg1) (arg1)->m_x = arg2;
21422
21423 resultobj = SWIG_Py_Void();
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21431 PyObject *resultobj = 0;
21432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21433 int result;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 PyObject *swig_obj[1] ;
21437
21438 if (!args) SWIG_fail;
21439 swig_obj[0] = args;
21440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21441 if (!SWIG_IsOK(res1)) {
21442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21443 }
21444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21445 result = (int) ((arg1)->m_x);
21446 resultobj = SWIG_From_int(static_cast< int >(result));
21447 return resultobj;
21448 fail:
21449 return NULL;
21450 }
21451
21452
21453 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21454 PyObject *resultobj = 0;
21455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21456 int arg2 ;
21457 void *argp1 = 0 ;
21458 int res1 = 0 ;
21459 int val2 ;
21460 int ecode2 = 0 ;
21461 PyObject *swig_obj[2] ;
21462
21463 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21465 if (!SWIG_IsOK(res1)) {
21466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21467 }
21468 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21469 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21470 if (!SWIG_IsOK(ecode2)) {
21471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21472 }
21473 arg2 = static_cast< int >(val2);
21474 if (arg1) (arg1)->m_y = arg2;
21475
21476 resultobj = SWIG_Py_Void();
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21484 PyObject *resultobj = 0;
21485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21486 int result;
21487 void *argp1 = 0 ;
21488 int res1 = 0 ;
21489 PyObject *swig_obj[1] ;
21490
21491 if (!args) SWIG_fail;
21492 swig_obj[0] = args;
21493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21494 if (!SWIG_IsOK(res1)) {
21495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21496 }
21497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21498 result = (int) ((arg1)->m_y);
21499 resultobj = SWIG_From_int(static_cast< int >(result));
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21507 PyObject *resultobj = 0;
21508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21509 bool arg2 ;
21510 void *argp1 = 0 ;
21511 int res1 = 0 ;
21512 bool val2 ;
21513 int ecode2 = 0 ;
21514 PyObject *swig_obj[2] ;
21515
21516 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21518 if (!SWIG_IsOK(res1)) {
21519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21520 }
21521 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21522 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21523 if (!SWIG_IsOK(ecode2)) {
21524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21525 }
21526 arg2 = static_cast< bool >(val2);
21527 if (arg1) (arg1)->m_leftDown = arg2;
21528
21529 resultobj = SWIG_Py_Void();
21530 return resultobj;
21531 fail:
21532 return NULL;
21533 }
21534
21535
21536 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21537 PyObject *resultobj = 0;
21538 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21539 bool result;
21540 void *argp1 = 0 ;
21541 int res1 = 0 ;
21542 PyObject *swig_obj[1] ;
21543
21544 if (!args) SWIG_fail;
21545 swig_obj[0] = args;
21546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21547 if (!SWIG_IsOK(res1)) {
21548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21549 }
21550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21551 result = (bool) ((arg1)->m_leftDown);
21552 {
21553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21554 }
21555 return resultobj;
21556 fail:
21557 return NULL;
21558 }
21559
21560
21561 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21562 PyObject *resultobj = 0;
21563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21564 bool arg2 ;
21565 void *argp1 = 0 ;
21566 int res1 = 0 ;
21567 bool val2 ;
21568 int ecode2 = 0 ;
21569 PyObject *swig_obj[2] ;
21570
21571 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21573 if (!SWIG_IsOK(res1)) {
21574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21575 }
21576 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21577 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21578 if (!SWIG_IsOK(ecode2)) {
21579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21580 }
21581 arg2 = static_cast< bool >(val2);
21582 if (arg1) (arg1)->m_middleDown = arg2;
21583
21584 resultobj = SWIG_Py_Void();
21585 return resultobj;
21586 fail:
21587 return NULL;
21588 }
21589
21590
21591 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21592 PyObject *resultobj = 0;
21593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21594 bool result;
21595 void *argp1 = 0 ;
21596 int res1 = 0 ;
21597 PyObject *swig_obj[1] ;
21598
21599 if (!args) SWIG_fail;
21600 swig_obj[0] = args;
21601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21602 if (!SWIG_IsOK(res1)) {
21603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21604 }
21605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21606 result = (bool) ((arg1)->m_middleDown);
21607 {
21608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21609 }
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 PyObject *resultobj = 0;
21618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21619 bool arg2 ;
21620 void *argp1 = 0 ;
21621 int res1 = 0 ;
21622 bool val2 ;
21623 int ecode2 = 0 ;
21624 PyObject *swig_obj[2] ;
21625
21626 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21628 if (!SWIG_IsOK(res1)) {
21629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21630 }
21631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21632 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21633 if (!SWIG_IsOK(ecode2)) {
21634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21635 }
21636 arg2 = static_cast< bool >(val2);
21637 if (arg1) (arg1)->m_rightDown = arg2;
21638
21639 resultobj = SWIG_Py_Void();
21640 return resultobj;
21641 fail:
21642 return NULL;
21643 }
21644
21645
21646 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21647 PyObject *resultobj = 0;
21648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21649 bool result;
21650 void *argp1 = 0 ;
21651 int res1 = 0 ;
21652 PyObject *swig_obj[1] ;
21653
21654 if (!args) SWIG_fail;
21655 swig_obj[0] = args;
21656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21657 if (!SWIG_IsOK(res1)) {
21658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21659 }
21660 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21661 result = (bool) ((arg1)->m_rightDown);
21662 {
21663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21664 }
21665 return resultobj;
21666 fail:
21667 return NULL;
21668 }
21669
21670
21671 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21672 PyObject *resultobj = 0;
21673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21674 bool arg2 ;
21675 void *argp1 = 0 ;
21676 int res1 = 0 ;
21677 bool val2 ;
21678 int ecode2 = 0 ;
21679 PyObject *swig_obj[2] ;
21680
21681 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21683 if (!SWIG_IsOK(res1)) {
21684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21685 }
21686 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21687 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21688 if (!SWIG_IsOK(ecode2)) {
21689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21690 }
21691 arg2 = static_cast< bool >(val2);
21692 if (arg1) (arg1)->m_controlDown = arg2;
21693
21694 resultobj = SWIG_Py_Void();
21695 return resultobj;
21696 fail:
21697 return NULL;
21698 }
21699
21700
21701 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21702 PyObject *resultobj = 0;
21703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21704 bool result;
21705 void *argp1 = 0 ;
21706 int res1 = 0 ;
21707 PyObject *swig_obj[1] ;
21708
21709 if (!args) SWIG_fail;
21710 swig_obj[0] = args;
21711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21712 if (!SWIG_IsOK(res1)) {
21713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21714 }
21715 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21716 result = (bool) ((arg1)->m_controlDown);
21717 {
21718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21719 }
21720 return resultobj;
21721 fail:
21722 return NULL;
21723 }
21724
21725
21726 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21727 PyObject *resultobj = 0;
21728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21729 bool arg2 ;
21730 void *argp1 = 0 ;
21731 int res1 = 0 ;
21732 bool val2 ;
21733 int ecode2 = 0 ;
21734 PyObject *swig_obj[2] ;
21735
21736 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21738 if (!SWIG_IsOK(res1)) {
21739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21740 }
21741 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21742 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21743 if (!SWIG_IsOK(ecode2)) {
21744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21745 }
21746 arg2 = static_cast< bool >(val2);
21747 if (arg1) (arg1)->m_shiftDown = arg2;
21748
21749 resultobj = SWIG_Py_Void();
21750 return resultobj;
21751 fail:
21752 return NULL;
21753 }
21754
21755
21756 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 PyObject *resultobj = 0;
21758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21759 bool result;
21760 void *argp1 = 0 ;
21761 int res1 = 0 ;
21762 PyObject *swig_obj[1] ;
21763
21764 if (!args) SWIG_fail;
21765 swig_obj[0] = args;
21766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21767 if (!SWIG_IsOK(res1)) {
21768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21769 }
21770 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21771 result = (bool) ((arg1)->m_shiftDown);
21772 {
21773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21774 }
21775 return resultobj;
21776 fail:
21777 return NULL;
21778 }
21779
21780
21781 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21782 PyObject *resultobj = 0;
21783 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21784 bool arg2 ;
21785 void *argp1 = 0 ;
21786 int res1 = 0 ;
21787 bool val2 ;
21788 int ecode2 = 0 ;
21789 PyObject *swig_obj[2] ;
21790
21791 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21793 if (!SWIG_IsOK(res1)) {
21794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21795 }
21796 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21797 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21798 if (!SWIG_IsOK(ecode2)) {
21799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21800 }
21801 arg2 = static_cast< bool >(val2);
21802 if (arg1) (arg1)->m_altDown = arg2;
21803
21804 resultobj = SWIG_Py_Void();
21805 return resultobj;
21806 fail:
21807 return NULL;
21808 }
21809
21810
21811 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21812 PyObject *resultobj = 0;
21813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21814 bool result;
21815 void *argp1 = 0 ;
21816 int res1 = 0 ;
21817 PyObject *swig_obj[1] ;
21818
21819 if (!args) SWIG_fail;
21820 swig_obj[0] = args;
21821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21824 }
21825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21826 result = (bool) ((arg1)->m_altDown);
21827 {
21828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21829 }
21830 return resultobj;
21831 fail:
21832 return NULL;
21833 }
21834
21835
21836 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21837 PyObject *resultobj = 0;
21838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21839 bool arg2 ;
21840 void *argp1 = 0 ;
21841 int res1 = 0 ;
21842 bool val2 ;
21843 int ecode2 = 0 ;
21844 PyObject *swig_obj[2] ;
21845
21846 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21848 if (!SWIG_IsOK(res1)) {
21849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21850 }
21851 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21852 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21853 if (!SWIG_IsOK(ecode2)) {
21854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21855 }
21856 arg2 = static_cast< bool >(val2);
21857 if (arg1) (arg1)->m_metaDown = arg2;
21858
21859 resultobj = SWIG_Py_Void();
21860 return resultobj;
21861 fail:
21862 return NULL;
21863 }
21864
21865
21866 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21867 PyObject *resultobj = 0;
21868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21869 bool result;
21870 void *argp1 = 0 ;
21871 int res1 = 0 ;
21872 PyObject *swig_obj[1] ;
21873
21874 if (!args) SWIG_fail;
21875 swig_obj[0] = args;
21876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21877 if (!SWIG_IsOK(res1)) {
21878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21879 }
21880 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21881 result = (bool) ((arg1)->m_metaDown);
21882 {
21883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21884 }
21885 return resultobj;
21886 fail:
21887 return NULL;
21888 }
21889
21890
21891 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21892 PyObject *resultobj = 0;
21893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21894 int arg2 ;
21895 void *argp1 = 0 ;
21896 int res1 = 0 ;
21897 int val2 ;
21898 int ecode2 = 0 ;
21899 PyObject *swig_obj[2] ;
21900
21901 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21903 if (!SWIG_IsOK(res1)) {
21904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21905 }
21906 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21907 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21908 if (!SWIG_IsOK(ecode2)) {
21909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21910 }
21911 arg2 = static_cast< int >(val2);
21912 if (arg1) (arg1)->m_wheelRotation = arg2;
21913
21914 resultobj = SWIG_Py_Void();
21915 return resultobj;
21916 fail:
21917 return NULL;
21918 }
21919
21920
21921 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21922 PyObject *resultobj = 0;
21923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21924 int result;
21925 void *argp1 = 0 ;
21926 int res1 = 0 ;
21927 PyObject *swig_obj[1] ;
21928
21929 if (!args) SWIG_fail;
21930 swig_obj[0] = args;
21931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21932 if (!SWIG_IsOK(res1)) {
21933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21934 }
21935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21936 result = (int) ((arg1)->m_wheelRotation);
21937 resultobj = SWIG_From_int(static_cast< int >(result));
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21945 PyObject *resultobj = 0;
21946 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21947 int arg2 ;
21948 void *argp1 = 0 ;
21949 int res1 = 0 ;
21950 int val2 ;
21951 int ecode2 = 0 ;
21952 PyObject *swig_obj[2] ;
21953
21954 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21956 if (!SWIG_IsOK(res1)) {
21957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21958 }
21959 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21960 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21961 if (!SWIG_IsOK(ecode2)) {
21962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21963 }
21964 arg2 = static_cast< int >(val2);
21965 if (arg1) (arg1)->m_wheelDelta = arg2;
21966
21967 resultobj = SWIG_Py_Void();
21968 return resultobj;
21969 fail:
21970 return NULL;
21971 }
21972
21973
21974 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21975 PyObject *resultobj = 0;
21976 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21977 int result;
21978 void *argp1 = 0 ;
21979 int res1 = 0 ;
21980 PyObject *swig_obj[1] ;
21981
21982 if (!args) SWIG_fail;
21983 swig_obj[0] = args;
21984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21985 if (!SWIG_IsOK(res1)) {
21986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21987 }
21988 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21989 result = (int) ((arg1)->m_wheelDelta);
21990 resultobj = SWIG_From_int(static_cast< int >(result));
21991 return resultobj;
21992 fail:
21993 return NULL;
21994 }
21995
21996
21997 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21998 PyObject *resultobj = 0;
21999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22000 int arg2 ;
22001 void *argp1 = 0 ;
22002 int res1 = 0 ;
22003 int val2 ;
22004 int ecode2 = 0 ;
22005 PyObject *swig_obj[2] ;
22006
22007 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22009 if (!SWIG_IsOK(res1)) {
22010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22011 }
22012 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22013 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22014 if (!SWIG_IsOK(ecode2)) {
22015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22016 }
22017 arg2 = static_cast< int >(val2);
22018 if (arg1) (arg1)->m_linesPerAction = arg2;
22019
22020 resultobj = SWIG_Py_Void();
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22028 PyObject *resultobj = 0;
22029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22030 int result;
22031 void *argp1 = 0 ;
22032 int res1 = 0 ;
22033 PyObject *swig_obj[1] ;
22034
22035 if (!args) SWIG_fail;
22036 swig_obj[0] = args;
22037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22038 if (!SWIG_IsOK(res1)) {
22039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22040 }
22041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22042 result = (int) ((arg1)->m_linesPerAction);
22043 resultobj = SWIG_From_int(static_cast< int >(result));
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *obj;
22052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22053 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22054 return SWIG_Py_Void();
22055 }
22056
22057 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22058 return SWIG_Python_InitShadowInstance(args);
22059 }
22060
22061 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj = 0;
22063 int arg1 = (int) 0 ;
22064 int arg2 = (int) 0 ;
22065 wxSetCursorEvent *result = 0 ;
22066 int val1 ;
22067 int ecode1 = 0 ;
22068 int val2 ;
22069 int ecode2 = 0 ;
22070 PyObject * obj0 = 0 ;
22071 PyObject * obj1 = 0 ;
22072 char * kwnames[] = {
22073 (char *) "x",(char *) "y", NULL
22074 };
22075
22076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22077 if (obj0) {
22078 ecode1 = SWIG_AsVal_int(obj0, &val1);
22079 if (!SWIG_IsOK(ecode1)) {
22080 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22081 }
22082 arg1 = static_cast< int >(val1);
22083 }
22084 if (obj1) {
22085 ecode2 = SWIG_AsVal_int(obj1, &val2);
22086 if (!SWIG_IsOK(ecode2)) {
22087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22088 }
22089 arg2 = static_cast< int >(val2);
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22094 wxPyEndAllowThreads(__tstate);
22095 if (PyErr_Occurred()) SWIG_fail;
22096 }
22097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22098 return resultobj;
22099 fail:
22100 return NULL;
22101 }
22102
22103
22104 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22105 PyObject *resultobj = 0;
22106 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22107 int result;
22108 void *argp1 = 0 ;
22109 int res1 = 0 ;
22110 PyObject *swig_obj[1] ;
22111
22112 if (!args) SWIG_fail;
22113 swig_obj[0] = args;
22114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22115 if (!SWIG_IsOK(res1)) {
22116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22117 }
22118 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22119 {
22120 PyThreadState* __tstate = wxPyBeginAllowThreads();
22121 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22122 wxPyEndAllowThreads(__tstate);
22123 if (PyErr_Occurred()) SWIG_fail;
22124 }
22125 resultobj = SWIG_From_int(static_cast< int >(result));
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22133 PyObject *resultobj = 0;
22134 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22135 int result;
22136 void *argp1 = 0 ;
22137 int res1 = 0 ;
22138 PyObject *swig_obj[1] ;
22139
22140 if (!args) SWIG_fail;
22141 swig_obj[0] = args;
22142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22145 }
22146 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22150 wxPyEndAllowThreads(__tstate);
22151 if (PyErr_Occurred()) SWIG_fail;
22152 }
22153 resultobj = SWIG_From_int(static_cast< int >(result));
22154 return resultobj;
22155 fail:
22156 return NULL;
22157 }
22158
22159
22160 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22161 PyObject *resultobj = 0;
22162 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22163 wxCursor *arg2 = 0 ;
22164 void *argp1 = 0 ;
22165 int res1 = 0 ;
22166 void *argp2 = 0 ;
22167 int res2 = 0 ;
22168 PyObject * obj0 = 0 ;
22169 PyObject * obj1 = 0 ;
22170 char * kwnames[] = {
22171 (char *) "self",(char *) "cursor", NULL
22172 };
22173
22174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22176 if (!SWIG_IsOK(res1)) {
22177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22178 }
22179 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22180 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22181 if (!SWIG_IsOK(res2)) {
22182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22183 }
22184 if (!argp2) {
22185 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22186 }
22187 arg2 = reinterpret_cast< wxCursor * >(argp2);
22188 {
22189 PyThreadState* __tstate = wxPyBeginAllowThreads();
22190 (arg1)->SetCursor((wxCursor const &)*arg2);
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 resultobj = SWIG_Py_Void();
22195 return resultobj;
22196 fail:
22197 return NULL;
22198 }
22199
22200
22201 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22202 PyObject *resultobj = 0;
22203 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22204 wxCursor *result = 0 ;
22205 void *argp1 = 0 ;
22206 int res1 = 0 ;
22207 PyObject *swig_obj[1] ;
22208
22209 if (!args) SWIG_fail;
22210 swig_obj[0] = args;
22211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22212 if (!SWIG_IsOK(res1)) {
22213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22214 }
22215 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22216 {
22217 PyThreadState* __tstate = wxPyBeginAllowThreads();
22218 {
22219 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22220 result = (wxCursor *) &_result_ref;
22221 }
22222 wxPyEndAllowThreads(__tstate);
22223 if (PyErr_Occurred()) SWIG_fail;
22224 }
22225 {
22226 wxCursor* resultptr = new wxCursor(*result);
22227 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22228 }
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22238 bool result;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 PyObject *swig_obj[1] ;
22242
22243 if (!args) SWIG_fail;
22244 swig_obj[0] = args;
22245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22246 if (!SWIG_IsOK(res1)) {
22247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22248 }
22249 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 {
22257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22258 }
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22266 PyObject *obj;
22267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22268 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22269 return SWIG_Py_Void();
22270 }
22271
22272 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22273 return SWIG_Python_InitShadowInstance(args);
22274 }
22275
22276 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22277 PyObject *resultobj = 0;
22278 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22279 wxKeyEvent *result = 0 ;
22280 int val1 ;
22281 int ecode1 = 0 ;
22282 PyObject * obj0 = 0 ;
22283 char * kwnames[] = {
22284 (char *) "eventType", NULL
22285 };
22286
22287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22288 if (obj0) {
22289 ecode1 = SWIG_AsVal_int(obj0, &val1);
22290 if (!SWIG_IsOK(ecode1)) {
22291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22292 }
22293 arg1 = static_cast< wxEventType >(val1);
22294 }
22295 {
22296 PyThreadState* __tstate = wxPyBeginAllowThreads();
22297 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22298 wxPyEndAllowThreads(__tstate);
22299 if (PyErr_Occurred()) SWIG_fail;
22300 }
22301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22302 return resultobj;
22303 fail:
22304 return NULL;
22305 }
22306
22307
22308 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22309 PyObject *resultobj = 0;
22310 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22311 int result;
22312 void *argp1 = 0 ;
22313 int res1 = 0 ;
22314 PyObject *swig_obj[1] ;
22315
22316 if (!args) SWIG_fail;
22317 swig_obj[0] = args;
22318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22319 if (!SWIG_IsOK(res1)) {
22320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22321 }
22322 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22323 {
22324 PyThreadState* __tstate = wxPyBeginAllowThreads();
22325 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 resultobj = SWIG_From_int(static_cast< int >(result));
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22337 PyObject *resultobj = 0;
22338 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22339 bool result;
22340 void *argp1 = 0 ;
22341 int res1 = 0 ;
22342 PyObject *swig_obj[1] ;
22343
22344 if (!args) SWIG_fail;
22345 swig_obj[0] = args;
22346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22347 if (!SWIG_IsOK(res1)) {
22348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22349 }
22350 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22351 {
22352 PyThreadState* __tstate = wxPyBeginAllowThreads();
22353 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22354 wxPyEndAllowThreads(__tstate);
22355 if (PyErr_Occurred()) SWIG_fail;
22356 }
22357 {
22358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22359 }
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22367 PyObject *resultobj = 0;
22368 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22369 bool result;
22370 void *argp1 = 0 ;
22371 int res1 = 0 ;
22372 PyObject *swig_obj[1] ;
22373
22374 if (!args) SWIG_fail;
22375 swig_obj[0] = args;
22376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22377 if (!SWIG_IsOK(res1)) {
22378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22379 }
22380 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22381 {
22382 PyThreadState* __tstate = wxPyBeginAllowThreads();
22383 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22384 wxPyEndAllowThreads(__tstate);
22385 if (PyErr_Occurred()) SWIG_fail;
22386 }
22387 {
22388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22389 }
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22397 PyObject *resultobj = 0;
22398 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22399 bool result;
22400 void *argp1 = 0 ;
22401 int res1 = 0 ;
22402 PyObject *swig_obj[1] ;
22403
22404 if (!args) SWIG_fail;
22405 swig_obj[0] = args;
22406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22409 }
22410 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 {
22418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22419 }
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22427 PyObject *resultobj = 0;
22428 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22429 bool result;
22430 void *argp1 = 0 ;
22431 int res1 = 0 ;
22432 PyObject *swig_obj[1] ;
22433
22434 if (!args) SWIG_fail;
22435 swig_obj[0] = args;
22436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22437 if (!SWIG_IsOK(res1)) {
22438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22439 }
22440 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22441 {
22442 PyThreadState* __tstate = wxPyBeginAllowThreads();
22443 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22444 wxPyEndAllowThreads(__tstate);
22445 if (PyErr_Occurred()) SWIG_fail;
22446 }
22447 {
22448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22449 }
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22457 PyObject *resultobj = 0;
22458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22459 bool result;
22460 void *argp1 = 0 ;
22461 int res1 = 0 ;
22462 PyObject *swig_obj[1] ;
22463
22464 if (!args) SWIG_fail;
22465 swig_obj[0] = args;
22466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22467 if (!SWIG_IsOK(res1)) {
22468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22469 }
22470 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22471 {
22472 PyThreadState* __tstate = wxPyBeginAllowThreads();
22473 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22474 wxPyEndAllowThreads(__tstate);
22475 if (PyErr_Occurred()) SWIG_fail;
22476 }
22477 {
22478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22479 }
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22487 PyObject *resultobj = 0;
22488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22489 bool result;
22490 void *argp1 = 0 ;
22491 int res1 = 0 ;
22492 PyObject *swig_obj[1] ;
22493
22494 if (!args) SWIG_fail;
22495 swig_obj[0] = args;
22496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22497 if (!SWIG_IsOK(res1)) {
22498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22499 }
22500 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22501 {
22502 PyThreadState* __tstate = wxPyBeginAllowThreads();
22503 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22504 wxPyEndAllowThreads(__tstate);
22505 if (PyErr_Occurred()) SWIG_fail;
22506 }
22507 {
22508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22509 }
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22517 PyObject *resultobj = 0;
22518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22519 int result;
22520 void *argp1 = 0 ;
22521 int res1 = 0 ;
22522 PyObject *swig_obj[1] ;
22523
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_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22529 }
22530 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22531 {
22532 PyThreadState* __tstate = wxPyBeginAllowThreads();
22533 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22534 wxPyEndAllowThreads(__tstate);
22535 if (PyErr_Occurred()) SWIG_fail;
22536 }
22537 resultobj = SWIG_From_int(static_cast< int >(result));
22538 return resultobj;
22539 fail:
22540 return NULL;
22541 }
22542
22543
22544 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22545 PyObject *resultobj = 0;
22546 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22547 int result;
22548 void *argp1 = 0 ;
22549 int res1 = 0 ;
22550 PyObject *swig_obj[1] ;
22551
22552 if (!args) SWIG_fail;
22553 swig_obj[0] = args;
22554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22555 if (!SWIG_IsOK(res1)) {
22556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22557 }
22558 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22559 {
22560 PyThreadState* __tstate = wxPyBeginAllowThreads();
22561 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22562 wxPyEndAllowThreads(__tstate);
22563 if (PyErr_Occurred()) SWIG_fail;
22564 }
22565 resultobj = SWIG_From_int(static_cast< int >(result));
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22573 PyObject *resultobj = 0;
22574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22575 int arg2 ;
22576 void *argp1 = 0 ;
22577 int res1 = 0 ;
22578 int val2 ;
22579 int ecode2 = 0 ;
22580 PyObject * obj0 = 0 ;
22581 PyObject * obj1 = 0 ;
22582 char * kwnames[] = {
22583 (char *) "self",(char *) "uniChar", NULL
22584 };
22585
22586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22588 if (!SWIG_IsOK(res1)) {
22589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22590 }
22591 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22592 ecode2 = SWIG_AsVal_int(obj1, &val2);
22593 if (!SWIG_IsOK(ecode2)) {
22594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22595 }
22596 arg2 = static_cast< int >(val2);
22597 {
22598 PyThreadState* __tstate = wxPyBeginAllowThreads();
22599 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22600 wxPyEndAllowThreads(__tstate);
22601 if (PyErr_Occurred()) SWIG_fail;
22602 }
22603 resultobj = SWIG_Py_Void();
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22611 PyObject *resultobj = 0;
22612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22613 unsigned int result;
22614 void *argp1 = 0 ;
22615 int res1 = 0 ;
22616 PyObject *swig_obj[1] ;
22617
22618 if (!args) SWIG_fail;
22619 swig_obj[0] = args;
22620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22621 if (!SWIG_IsOK(res1)) {
22622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22623 }
22624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22625 {
22626 PyThreadState* __tstate = wxPyBeginAllowThreads();
22627 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22628 wxPyEndAllowThreads(__tstate);
22629 if (PyErr_Occurred()) SWIG_fail;
22630 }
22631 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22632 return resultobj;
22633 fail:
22634 return NULL;
22635 }
22636
22637
22638 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22639 PyObject *resultobj = 0;
22640 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22641 unsigned int result;
22642 void *argp1 = 0 ;
22643 int res1 = 0 ;
22644 PyObject *swig_obj[1] ;
22645
22646 if (!args) SWIG_fail;
22647 swig_obj[0] = args;
22648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22649 if (!SWIG_IsOK(res1)) {
22650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22651 }
22652 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22653 {
22654 PyThreadState* __tstate = wxPyBeginAllowThreads();
22655 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22656 wxPyEndAllowThreads(__tstate);
22657 if (PyErr_Occurred()) SWIG_fail;
22658 }
22659 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22660 return resultobj;
22661 fail:
22662 return NULL;
22663 }
22664
22665
22666 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22667 PyObject *resultobj = 0;
22668 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22669 wxPoint result;
22670 void *argp1 = 0 ;
22671 int res1 = 0 ;
22672 PyObject *swig_obj[1] ;
22673
22674 if (!args) SWIG_fail;
22675 swig_obj[0] = args;
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_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22679 }
22680 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22681 {
22682 PyThreadState* __tstate = wxPyBeginAllowThreads();
22683 result = (arg1)->GetPosition();
22684 wxPyEndAllowThreads(__tstate);
22685 if (PyErr_Occurred()) SWIG_fail;
22686 }
22687 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22688 return resultobj;
22689 fail:
22690 return NULL;
22691 }
22692
22693
22694 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22695 PyObject *resultobj = 0;
22696 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22697 long *arg2 = (long *) 0 ;
22698 long *arg3 = (long *) 0 ;
22699 void *argp1 = 0 ;
22700 int res1 = 0 ;
22701 long temp2 ;
22702 int res2 = SWIG_TMPOBJ ;
22703 long temp3 ;
22704 int res3 = SWIG_TMPOBJ ;
22705 PyObject *swig_obj[1] ;
22706
22707 arg2 = &temp2;
22708 arg3 = &temp3;
22709 if (!args) SWIG_fail;
22710 swig_obj[0] = args;
22711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22712 if (!SWIG_IsOK(res1)) {
22713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22714 }
22715 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22716 {
22717 PyThreadState* __tstate = wxPyBeginAllowThreads();
22718 (arg1)->GetPosition(arg2,arg3);
22719 wxPyEndAllowThreads(__tstate);
22720 if (PyErr_Occurred()) SWIG_fail;
22721 }
22722 resultobj = SWIG_Py_Void();
22723 if (SWIG_IsTmpObj(res2)) {
22724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22725 } else {
22726 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22728 }
22729 if (SWIG_IsTmpObj(res3)) {
22730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22731 } else {
22732 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22734 }
22735 return resultobj;
22736 fail:
22737 return NULL;
22738 }
22739
22740
22741 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22742 PyObject *resultobj = 0;
22743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22744 int result;
22745 void *argp1 = 0 ;
22746 int res1 = 0 ;
22747 PyObject *swig_obj[1] ;
22748
22749 if (!args) SWIG_fail;
22750 swig_obj[0] = args;
22751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22752 if (!SWIG_IsOK(res1)) {
22753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22754 }
22755 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 result = (int)((wxKeyEvent const *)arg1)->GetX();
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 resultobj = SWIG_From_int(static_cast< int >(result));
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22770 PyObject *resultobj = 0;
22771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22772 int result;
22773 void *argp1 = 0 ;
22774 int res1 = 0 ;
22775 PyObject *swig_obj[1] ;
22776
22777 if (!args) SWIG_fail;
22778 swig_obj[0] = args;
22779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22780 if (!SWIG_IsOK(res1)) {
22781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22782 }
22783 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 result = (int)((wxKeyEvent const *)arg1)->GetY();
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 resultobj = SWIG_From_int(static_cast< int >(result));
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22798 PyObject *resultobj = 0;
22799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22800 int arg2 ;
22801 void *argp1 = 0 ;
22802 int res1 = 0 ;
22803 int val2 ;
22804 int ecode2 = 0 ;
22805 PyObject *swig_obj[2] ;
22806
22807 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22809 if (!SWIG_IsOK(res1)) {
22810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22811 }
22812 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22813 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22814 if (!SWIG_IsOK(ecode2)) {
22815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22816 }
22817 arg2 = static_cast< int >(val2);
22818 if (arg1) (arg1)->m_x = arg2;
22819
22820 resultobj = SWIG_Py_Void();
22821 return resultobj;
22822 fail:
22823 return NULL;
22824 }
22825
22826
22827 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22828 PyObject *resultobj = 0;
22829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22830 int result;
22831 void *argp1 = 0 ;
22832 int res1 = 0 ;
22833 PyObject *swig_obj[1] ;
22834
22835 if (!args) SWIG_fail;
22836 swig_obj[0] = args;
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_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22842 result = (int) ((arg1)->m_x);
22843 resultobj = SWIG_From_int(static_cast< int >(result));
22844 return resultobj;
22845 fail:
22846 return NULL;
22847 }
22848
22849
22850 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22851 PyObject *resultobj = 0;
22852 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22853 int arg2 ;
22854 void *argp1 = 0 ;
22855 int res1 = 0 ;
22856 int val2 ;
22857 int ecode2 = 0 ;
22858 PyObject *swig_obj[2] ;
22859
22860 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22862 if (!SWIG_IsOK(res1)) {
22863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22864 }
22865 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22866 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22867 if (!SWIG_IsOK(ecode2)) {
22868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22869 }
22870 arg2 = static_cast< int >(val2);
22871 if (arg1) (arg1)->m_y = arg2;
22872
22873 resultobj = SWIG_Py_Void();
22874 return resultobj;
22875 fail:
22876 return NULL;
22877 }
22878
22879
22880 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22881 PyObject *resultobj = 0;
22882 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22883 int result;
22884 void *argp1 = 0 ;
22885 int res1 = 0 ;
22886 PyObject *swig_obj[1] ;
22887
22888 if (!args) SWIG_fail;
22889 swig_obj[0] = args;
22890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22891 if (!SWIG_IsOK(res1)) {
22892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22893 }
22894 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22895 result = (int) ((arg1)->m_y);
22896 resultobj = SWIG_From_int(static_cast< int >(result));
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22904 PyObject *resultobj = 0;
22905 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22906 long arg2 ;
22907 void *argp1 = 0 ;
22908 int res1 = 0 ;
22909 long val2 ;
22910 int ecode2 = 0 ;
22911 PyObject *swig_obj[2] ;
22912
22913 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22915 if (!SWIG_IsOK(res1)) {
22916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22917 }
22918 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22919 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22920 if (!SWIG_IsOK(ecode2)) {
22921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22922 }
22923 arg2 = static_cast< long >(val2);
22924 if (arg1) (arg1)->m_keyCode = arg2;
22925
22926 resultobj = SWIG_Py_Void();
22927 return resultobj;
22928 fail:
22929 return NULL;
22930 }
22931
22932
22933 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22934 PyObject *resultobj = 0;
22935 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22936 long result;
22937 void *argp1 = 0 ;
22938 int res1 = 0 ;
22939 PyObject *swig_obj[1] ;
22940
22941 if (!args) SWIG_fail;
22942 swig_obj[0] = args;
22943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22944 if (!SWIG_IsOK(res1)) {
22945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22946 }
22947 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22948 result = (long) ((arg1)->m_keyCode);
22949 resultobj = SWIG_From_long(static_cast< long >(result));
22950 return resultobj;
22951 fail:
22952 return NULL;
22953 }
22954
22955
22956 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22957 PyObject *resultobj = 0;
22958 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22959 bool arg2 ;
22960 void *argp1 = 0 ;
22961 int res1 = 0 ;
22962 bool val2 ;
22963 int ecode2 = 0 ;
22964 PyObject *swig_obj[2] ;
22965
22966 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22968 if (!SWIG_IsOK(res1)) {
22969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22970 }
22971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22972 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22973 if (!SWIG_IsOK(ecode2)) {
22974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22975 }
22976 arg2 = static_cast< bool >(val2);
22977 if (arg1) (arg1)->m_controlDown = arg2;
22978
22979 resultobj = SWIG_Py_Void();
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22987 PyObject *resultobj = 0;
22988 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22989 bool result;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 PyObject *swig_obj[1] ;
22993
22994 if (!args) SWIG_fail;
22995 swig_obj[0] = args;
22996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22997 if (!SWIG_IsOK(res1)) {
22998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22999 }
23000 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23001 result = (bool) ((arg1)->m_controlDown);
23002 {
23003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23004 }
23005 return resultobj;
23006 fail:
23007 return NULL;
23008 }
23009
23010
23011 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23012 PyObject *resultobj = 0;
23013 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23014 bool arg2 ;
23015 void *argp1 = 0 ;
23016 int res1 = 0 ;
23017 bool val2 ;
23018 int ecode2 = 0 ;
23019 PyObject *swig_obj[2] ;
23020
23021 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23023 if (!SWIG_IsOK(res1)) {
23024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23025 }
23026 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23027 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23028 if (!SWIG_IsOK(ecode2)) {
23029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23030 }
23031 arg2 = static_cast< bool >(val2);
23032 if (arg1) (arg1)->m_shiftDown = arg2;
23033
23034 resultobj = SWIG_Py_Void();
23035 return resultobj;
23036 fail:
23037 return NULL;
23038 }
23039
23040
23041 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23042 PyObject *resultobj = 0;
23043 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23044 bool result;
23045 void *argp1 = 0 ;
23046 int res1 = 0 ;
23047 PyObject *swig_obj[1] ;
23048
23049 if (!args) SWIG_fail;
23050 swig_obj[0] = args;
23051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23052 if (!SWIG_IsOK(res1)) {
23053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23054 }
23055 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23056 result = (bool) ((arg1)->m_shiftDown);
23057 {
23058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23059 }
23060 return resultobj;
23061 fail:
23062 return NULL;
23063 }
23064
23065
23066 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23067 PyObject *resultobj = 0;
23068 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23069 bool arg2 ;
23070 void *argp1 = 0 ;
23071 int res1 = 0 ;
23072 bool val2 ;
23073 int ecode2 = 0 ;
23074 PyObject *swig_obj[2] ;
23075
23076 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23078 if (!SWIG_IsOK(res1)) {
23079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23080 }
23081 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23082 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23083 if (!SWIG_IsOK(ecode2)) {
23084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23085 }
23086 arg2 = static_cast< bool >(val2);
23087 if (arg1) (arg1)->m_altDown = arg2;
23088
23089 resultobj = SWIG_Py_Void();
23090 return resultobj;
23091 fail:
23092 return NULL;
23093 }
23094
23095
23096 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23097 PyObject *resultobj = 0;
23098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23099 bool result;
23100 void *argp1 = 0 ;
23101 int res1 = 0 ;
23102 PyObject *swig_obj[1] ;
23103
23104 if (!args) SWIG_fail;
23105 swig_obj[0] = args;
23106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23107 if (!SWIG_IsOK(res1)) {
23108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23109 }
23110 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23111 result = (bool) ((arg1)->m_altDown);
23112 {
23113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23114 }
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23122 PyObject *resultobj = 0;
23123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23124 bool arg2 ;
23125 void *argp1 = 0 ;
23126 int res1 = 0 ;
23127 bool val2 ;
23128 int ecode2 = 0 ;
23129 PyObject *swig_obj[2] ;
23130
23131 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23133 if (!SWIG_IsOK(res1)) {
23134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23135 }
23136 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23137 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23138 if (!SWIG_IsOK(ecode2)) {
23139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23140 }
23141 arg2 = static_cast< bool >(val2);
23142 if (arg1) (arg1)->m_metaDown = arg2;
23143
23144 resultobj = SWIG_Py_Void();
23145 return resultobj;
23146 fail:
23147 return NULL;
23148 }
23149
23150
23151 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23152 PyObject *resultobj = 0;
23153 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23154 bool result;
23155 void *argp1 = 0 ;
23156 int res1 = 0 ;
23157 PyObject *swig_obj[1] ;
23158
23159 if (!args) SWIG_fail;
23160 swig_obj[0] = args;
23161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23162 if (!SWIG_IsOK(res1)) {
23163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23164 }
23165 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23166 result = (bool) ((arg1)->m_metaDown);
23167 {
23168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23169 }
23170 return resultobj;
23171 fail:
23172 return NULL;
23173 }
23174
23175
23176 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23177 PyObject *resultobj = 0;
23178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23179 bool arg2 ;
23180 void *argp1 = 0 ;
23181 int res1 = 0 ;
23182 bool val2 ;
23183 int ecode2 = 0 ;
23184 PyObject *swig_obj[2] ;
23185
23186 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23188 if (!SWIG_IsOK(res1)) {
23189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23190 }
23191 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23192 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23193 if (!SWIG_IsOK(ecode2)) {
23194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23195 }
23196 arg2 = static_cast< bool >(val2);
23197 if (arg1) (arg1)->m_scanCode = arg2;
23198
23199 resultobj = SWIG_Py_Void();
23200 return resultobj;
23201 fail:
23202 return NULL;
23203 }
23204
23205
23206 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23207 PyObject *resultobj = 0;
23208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23209 bool result;
23210 void *argp1 = 0 ;
23211 int res1 = 0 ;
23212 PyObject *swig_obj[1] ;
23213
23214 if (!args) SWIG_fail;
23215 swig_obj[0] = args;
23216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23217 if (!SWIG_IsOK(res1)) {
23218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23219 }
23220 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23221 result = (bool) ((arg1)->m_scanCode);
23222 {
23223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23224 }
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23232 PyObject *resultobj = 0;
23233 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23234 unsigned int arg2 ;
23235 void *argp1 = 0 ;
23236 int res1 = 0 ;
23237 unsigned int val2 ;
23238 int ecode2 = 0 ;
23239 PyObject *swig_obj[2] ;
23240
23241 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23243 if (!SWIG_IsOK(res1)) {
23244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23245 }
23246 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23247 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23248 if (!SWIG_IsOK(ecode2)) {
23249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23250 }
23251 arg2 = static_cast< unsigned int >(val2);
23252 if (arg1) (arg1)->m_rawCode = arg2;
23253
23254 resultobj = SWIG_Py_Void();
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23262 PyObject *resultobj = 0;
23263 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23264 unsigned int result;
23265 void *argp1 = 0 ;
23266 int res1 = 0 ;
23267 PyObject *swig_obj[1] ;
23268
23269 if (!args) SWIG_fail;
23270 swig_obj[0] = args;
23271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23272 if (!SWIG_IsOK(res1)) {
23273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23274 }
23275 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23276 result = (unsigned int) ((arg1)->m_rawCode);
23277 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23285 PyObject *resultobj = 0;
23286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23287 unsigned int arg2 ;
23288 void *argp1 = 0 ;
23289 int res1 = 0 ;
23290 unsigned int val2 ;
23291 int ecode2 = 0 ;
23292 PyObject *swig_obj[2] ;
23293
23294 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23296 if (!SWIG_IsOK(res1)) {
23297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23298 }
23299 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23300 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23301 if (!SWIG_IsOK(ecode2)) {
23302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23303 }
23304 arg2 = static_cast< unsigned int >(val2);
23305 if (arg1) (arg1)->m_rawFlags = arg2;
23306
23307 resultobj = SWIG_Py_Void();
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23315 PyObject *resultobj = 0;
23316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23317 unsigned int result;
23318 void *argp1 = 0 ;
23319 int res1 = 0 ;
23320 PyObject *swig_obj[1] ;
23321
23322 if (!args) SWIG_fail;
23323 swig_obj[0] = args;
23324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23325 if (!SWIG_IsOK(res1)) {
23326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23327 }
23328 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23329 result = (unsigned int) ((arg1)->m_rawFlags);
23330 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23338 PyObject *obj;
23339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23340 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23341 return SWIG_Py_Void();
23342 }
23343
23344 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23345 return SWIG_Python_InitShadowInstance(args);
23346 }
23347
23348 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23349 PyObject *resultobj = 0;
23350 wxSize const &arg1_defvalue = wxDefaultSize ;
23351 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23352 int arg2 = (int) 0 ;
23353 wxSizeEvent *result = 0 ;
23354 wxSize temp1 ;
23355 int val2 ;
23356 int ecode2 = 0 ;
23357 PyObject * obj0 = 0 ;
23358 PyObject * obj1 = 0 ;
23359 char * kwnames[] = {
23360 (char *) "sz",(char *) "winid", NULL
23361 };
23362
23363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23364 if (obj0) {
23365 {
23366 arg1 = &temp1;
23367 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23368 }
23369 }
23370 if (obj1) {
23371 ecode2 = SWIG_AsVal_int(obj1, &val2);
23372 if (!SWIG_IsOK(ecode2)) {
23373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23374 }
23375 arg2 = static_cast< int >(val2);
23376 }
23377 {
23378 PyThreadState* __tstate = wxPyBeginAllowThreads();
23379 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23380 wxPyEndAllowThreads(__tstate);
23381 if (PyErr_Occurred()) SWIG_fail;
23382 }
23383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23391 PyObject *resultobj = 0;
23392 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23393 wxSize result;
23394 void *argp1 = 0 ;
23395 int res1 = 0 ;
23396 PyObject *swig_obj[1] ;
23397
23398 if (!args) SWIG_fail;
23399 swig_obj[0] = args;
23400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23401 if (!SWIG_IsOK(res1)) {
23402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23403 }
23404 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 result = ((wxSizeEvent const *)arg1)->GetSize();
23408 wxPyEndAllowThreads(__tstate);
23409 if (PyErr_Occurred()) SWIG_fail;
23410 }
23411 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23419 PyObject *resultobj = 0;
23420 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23421 wxRect result;
23422 void *argp1 = 0 ;
23423 int res1 = 0 ;
23424 PyObject *swig_obj[1] ;
23425
23426 if (!args) SWIG_fail;
23427 swig_obj[0] = args;
23428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23429 if (!SWIG_IsOK(res1)) {
23430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23431 }
23432 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23433 {
23434 PyThreadState* __tstate = wxPyBeginAllowThreads();
23435 result = ((wxSizeEvent const *)arg1)->GetRect();
23436 wxPyEndAllowThreads(__tstate);
23437 if (PyErr_Occurred()) SWIG_fail;
23438 }
23439 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23440 return resultobj;
23441 fail:
23442 return NULL;
23443 }
23444
23445
23446 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23447 PyObject *resultobj = 0;
23448 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23449 wxRect arg2 ;
23450 void *argp1 = 0 ;
23451 int res1 = 0 ;
23452 void *argp2 ;
23453 int res2 = 0 ;
23454 PyObject * obj0 = 0 ;
23455 PyObject * obj1 = 0 ;
23456 char * kwnames[] = {
23457 (char *) "self",(char *) "rect", NULL
23458 };
23459
23460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23462 if (!SWIG_IsOK(res1)) {
23463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23464 }
23465 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23466 {
23467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23468 if (!SWIG_IsOK(res2)) {
23469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23470 }
23471 if (!argp2) {
23472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23473 } else {
23474 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23475 arg2 = *temp;
23476 if (SWIG_IsNewObj(res2)) delete temp;
23477 }
23478 }
23479 {
23480 PyThreadState* __tstate = wxPyBeginAllowThreads();
23481 (arg1)->SetRect(arg2);
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 resultobj = SWIG_Py_Void();
23486 return resultobj;
23487 fail:
23488 return NULL;
23489 }
23490
23491
23492 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj = 0;
23494 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23495 wxSize arg2 ;
23496 void *argp1 = 0 ;
23497 int res1 = 0 ;
23498 void *argp2 ;
23499 int res2 = 0 ;
23500 PyObject * obj0 = 0 ;
23501 PyObject * obj1 = 0 ;
23502 char * kwnames[] = {
23503 (char *) "self",(char *) "size", NULL
23504 };
23505
23506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23510 }
23511 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23512 {
23513 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23514 if (!SWIG_IsOK(res2)) {
23515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23516 }
23517 if (!argp2) {
23518 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23519 } else {
23520 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23521 arg2 = *temp;
23522 if (SWIG_IsNewObj(res2)) delete temp;
23523 }
23524 }
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 wxSizeEvent_SetSize(arg1,arg2);
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 resultobj = SWIG_Py_Void();
23532 return resultobj;
23533 fail:
23534 return NULL;
23535 }
23536
23537
23538 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23539 PyObject *resultobj = 0;
23540 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23541 wxSize *arg2 = (wxSize *) 0 ;
23542 void *argp1 = 0 ;
23543 int res1 = 0 ;
23544 void *argp2 = 0 ;
23545 int res2 = 0 ;
23546 PyObject *swig_obj[2] ;
23547
23548 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23550 if (!SWIG_IsOK(res1)) {
23551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23552 }
23553 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23554 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23555 if (!SWIG_IsOK(res2)) {
23556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23557 }
23558 arg2 = reinterpret_cast< wxSize * >(argp2);
23559 if (arg1) (arg1)->m_size = *arg2;
23560
23561 resultobj = SWIG_Py_Void();
23562 return resultobj;
23563 fail:
23564 return NULL;
23565 }
23566
23567
23568 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23569 PyObject *resultobj = 0;
23570 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23571 wxSize *result = 0 ;
23572 void *argp1 = 0 ;
23573 int res1 = 0 ;
23574 PyObject *swig_obj[1] ;
23575
23576 if (!args) SWIG_fail;
23577 swig_obj[0] = args;
23578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23579 if (!SWIG_IsOK(res1)) {
23580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23581 }
23582 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23583 result = (wxSize *)& ((arg1)->m_size);
23584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23594 wxRect *arg2 = (wxRect *) 0 ;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 void *argp2 = 0 ;
23598 int res2 = 0 ;
23599 PyObject *swig_obj[2] ;
23600
23601 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23603 if (!SWIG_IsOK(res1)) {
23604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23605 }
23606 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23607 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23608 if (!SWIG_IsOK(res2)) {
23609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23610 }
23611 arg2 = reinterpret_cast< wxRect * >(argp2);
23612 if (arg1) (arg1)->m_rect = *arg2;
23613
23614 resultobj = SWIG_Py_Void();
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *resultobj = 0;
23623 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23624 wxRect *result = 0 ;
23625 void *argp1 = 0 ;
23626 int res1 = 0 ;
23627 PyObject *swig_obj[1] ;
23628
23629 if (!args) SWIG_fail;
23630 swig_obj[0] = args;
23631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23632 if (!SWIG_IsOK(res1)) {
23633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23634 }
23635 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23636 result = (wxRect *)& ((arg1)->m_rect);
23637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23645 PyObject *obj;
23646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23647 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23648 return SWIG_Py_Void();
23649 }
23650
23651 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23652 return SWIG_Python_InitShadowInstance(args);
23653 }
23654
23655 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj = 0;
23657 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23658 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23659 int arg2 = (int) 0 ;
23660 wxMoveEvent *result = 0 ;
23661 wxPoint temp1 ;
23662 int val2 ;
23663 int ecode2 = 0 ;
23664 PyObject * obj0 = 0 ;
23665 PyObject * obj1 = 0 ;
23666 char * kwnames[] = {
23667 (char *) "pos",(char *) "winid", NULL
23668 };
23669
23670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23671 if (obj0) {
23672 {
23673 arg1 = &temp1;
23674 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23675 }
23676 }
23677 if (obj1) {
23678 ecode2 = SWIG_AsVal_int(obj1, &val2);
23679 if (!SWIG_IsOK(ecode2)) {
23680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23681 }
23682 arg2 = static_cast< int >(val2);
23683 }
23684 {
23685 PyThreadState* __tstate = wxPyBeginAllowThreads();
23686 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23698 PyObject *resultobj = 0;
23699 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23700 wxPoint result;
23701 void *argp1 = 0 ;
23702 int res1 = 0 ;
23703 PyObject *swig_obj[1] ;
23704
23705 if (!args) SWIG_fail;
23706 swig_obj[0] = args;
23707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23708 if (!SWIG_IsOK(res1)) {
23709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23710 }
23711 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23712 {
23713 PyThreadState* __tstate = wxPyBeginAllowThreads();
23714 result = ((wxMoveEvent const *)arg1)->GetPosition();
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23726 PyObject *resultobj = 0;
23727 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23728 wxRect result;
23729 void *argp1 = 0 ;
23730 int res1 = 0 ;
23731 PyObject *swig_obj[1] ;
23732
23733 if (!args) SWIG_fail;
23734 swig_obj[0] = args;
23735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23736 if (!SWIG_IsOK(res1)) {
23737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23738 }
23739 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 result = ((wxMoveEvent const *)arg1)->GetRect();
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23754 PyObject *resultobj = 0;
23755 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23756 wxRect *arg2 = 0 ;
23757 void *argp1 = 0 ;
23758 int res1 = 0 ;
23759 wxRect temp2 ;
23760 PyObject * obj0 = 0 ;
23761 PyObject * obj1 = 0 ;
23762 char * kwnames[] = {
23763 (char *) "self",(char *) "rect", NULL
23764 };
23765
23766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23768 if (!SWIG_IsOK(res1)) {
23769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23770 }
23771 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23772 {
23773 arg2 = &temp2;
23774 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23775 }
23776 {
23777 PyThreadState* __tstate = wxPyBeginAllowThreads();
23778 (arg1)->SetRect((wxRect const &)*arg2);
23779 wxPyEndAllowThreads(__tstate);
23780 if (PyErr_Occurred()) SWIG_fail;
23781 }
23782 resultobj = SWIG_Py_Void();
23783 return resultobj;
23784 fail:
23785 return NULL;
23786 }
23787
23788
23789 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23790 PyObject *resultobj = 0;
23791 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23792 wxPoint *arg2 = 0 ;
23793 void *argp1 = 0 ;
23794 int res1 = 0 ;
23795 wxPoint temp2 ;
23796 PyObject * obj0 = 0 ;
23797 PyObject * obj1 = 0 ;
23798 char * kwnames[] = {
23799 (char *) "self",(char *) "pos", NULL
23800 };
23801
23802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23804 if (!SWIG_IsOK(res1)) {
23805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23806 }
23807 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23808 {
23809 arg2 = &temp2;
23810 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23811 }
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 (arg1)->SetPosition((wxPoint const &)*arg2);
23815 wxPyEndAllowThreads(__tstate);
23816 if (PyErr_Occurred()) SWIG_fail;
23817 }
23818 resultobj = SWIG_Py_Void();
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *obj;
23827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23828 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23829 return SWIG_Py_Void();
23830 }
23831
23832 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23833 return SWIG_Python_InitShadowInstance(args);
23834 }
23835
23836 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj = 0;
23838 int arg1 = (int) 0 ;
23839 wxPaintEvent *result = 0 ;
23840 int val1 ;
23841 int ecode1 = 0 ;
23842 PyObject * obj0 = 0 ;
23843 char * kwnames[] = {
23844 (char *) "Id", NULL
23845 };
23846
23847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23848 if (obj0) {
23849 ecode1 = SWIG_AsVal_int(obj0, &val1);
23850 if (!SWIG_IsOK(ecode1)) {
23851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23852 }
23853 arg1 = static_cast< int >(val1);
23854 }
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *obj;
23870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23871 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23872 return SWIG_Py_Void();
23873 }
23874
23875 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 return SWIG_Python_InitShadowInstance(args);
23877 }
23878
23879 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj = 0;
23881 int arg1 = (int) 0 ;
23882 wxNcPaintEvent *result = 0 ;
23883 int val1 ;
23884 int ecode1 = 0 ;
23885 PyObject * obj0 = 0 ;
23886 char * kwnames[] = {
23887 (char *) "winid", NULL
23888 };
23889
23890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23891 if (obj0) {
23892 ecode1 = SWIG_AsVal_int(obj0, &val1);
23893 if (!SWIG_IsOK(ecode1)) {
23894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23895 }
23896 arg1 = static_cast< int >(val1);
23897 }
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23912 PyObject *obj;
23913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23914 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23915 return SWIG_Py_Void();
23916 }
23917
23918 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23919 return SWIG_Python_InitShadowInstance(args);
23920 }
23921
23922 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj = 0;
23924 int arg1 = (int) 0 ;
23925 wxDC *arg2 = (wxDC *) NULL ;
23926 wxEraseEvent *result = 0 ;
23927 int val1 ;
23928 int ecode1 = 0 ;
23929 void *argp2 = 0 ;
23930 int res2 = 0 ;
23931 PyObject * obj0 = 0 ;
23932 PyObject * obj1 = 0 ;
23933 char * kwnames[] = {
23934 (char *) "Id",(char *) "dc", NULL
23935 };
23936
23937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23938 if (obj0) {
23939 ecode1 = SWIG_AsVal_int(obj0, &val1);
23940 if (!SWIG_IsOK(ecode1)) {
23941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23942 }
23943 arg1 = static_cast< int >(val1);
23944 }
23945 if (obj1) {
23946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23947 if (!SWIG_IsOK(res2)) {
23948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23949 }
23950 arg2 = reinterpret_cast< wxDC * >(argp2);
23951 }
23952 {
23953 PyThreadState* __tstate = wxPyBeginAllowThreads();
23954 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23959 return resultobj;
23960 fail:
23961 return NULL;
23962 }
23963
23964
23965 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23966 PyObject *resultobj = 0;
23967 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23968 wxDC *result = 0 ;
23969 void *argp1 = 0 ;
23970 int res1 = 0 ;
23971 PyObject *swig_obj[1] ;
23972
23973 if (!args) SWIG_fail;
23974 swig_obj[0] = args;
23975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23976 if (!SWIG_IsOK(res1)) {
23977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23978 }
23979 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 {
23987 resultobj = wxPyMake_wxObject(result, (bool)0);
23988 }
23989 return resultobj;
23990 fail:
23991 return NULL;
23992 }
23993
23994
23995 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23996 PyObject *obj;
23997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23998 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23999 return SWIG_Py_Void();
24000 }
24001
24002 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24003 return SWIG_Python_InitShadowInstance(args);
24004 }
24005
24006 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24007 PyObject *resultobj = 0;
24008 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24009 int arg2 = (int) 0 ;
24010 wxFocusEvent *result = 0 ;
24011 int val1 ;
24012 int ecode1 = 0 ;
24013 int val2 ;
24014 int ecode2 = 0 ;
24015 PyObject * obj0 = 0 ;
24016 PyObject * obj1 = 0 ;
24017 char * kwnames[] = {
24018 (char *) "type",(char *) "winid", NULL
24019 };
24020
24021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24022 if (obj0) {
24023 ecode1 = SWIG_AsVal_int(obj0, &val1);
24024 if (!SWIG_IsOK(ecode1)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24026 }
24027 arg1 = static_cast< wxEventType >(val1);
24028 }
24029 if (obj1) {
24030 ecode2 = SWIG_AsVal_int(obj1, &val2);
24031 if (!SWIG_IsOK(ecode2)) {
24032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24033 }
24034 arg2 = static_cast< int >(val2);
24035 }
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24050 PyObject *resultobj = 0;
24051 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24052 wxWindow *result = 0 ;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 PyObject *swig_obj[1] ;
24056
24057 if (!args) SWIG_fail;
24058 swig_obj[0] = args;
24059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24060 if (!SWIG_IsOK(res1)) {
24061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24062 }
24063 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 {
24071 resultobj = wxPyMake_wxObject(result, (bool)0);
24072 }
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24080 PyObject *resultobj = 0;
24081 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24082 wxWindow *arg2 = (wxWindow *) 0 ;
24083 void *argp1 = 0 ;
24084 int res1 = 0 ;
24085 void *argp2 = 0 ;
24086 int res2 = 0 ;
24087 PyObject * obj0 = 0 ;
24088 PyObject * obj1 = 0 ;
24089 char * kwnames[] = {
24090 (char *) "self",(char *) "win", NULL
24091 };
24092
24093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24097 }
24098 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24099 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24100 if (!SWIG_IsOK(res2)) {
24101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24102 }
24103 arg2 = reinterpret_cast< wxWindow * >(argp2);
24104 {
24105 PyThreadState* __tstate = wxPyBeginAllowThreads();
24106 (arg1)->SetWindow(arg2);
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 resultobj = SWIG_Py_Void();
24111 return resultobj;
24112 fail:
24113 return NULL;
24114 }
24115
24116
24117 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24118 PyObject *obj;
24119 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24120 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24121 return SWIG_Py_Void();
24122 }
24123
24124 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24125 return SWIG_Python_InitShadowInstance(args);
24126 }
24127
24128 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24129 PyObject *resultobj = 0;
24130 wxWindow *arg1 = (wxWindow *) NULL ;
24131 wxChildFocusEvent *result = 0 ;
24132 void *argp1 = 0 ;
24133 int res1 = 0 ;
24134 PyObject * obj0 = 0 ;
24135 char * kwnames[] = {
24136 (char *) "win", NULL
24137 };
24138
24139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24140 if (obj0) {
24141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24142 if (!SWIG_IsOK(res1)) {
24143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24144 }
24145 arg1 = reinterpret_cast< wxWindow * >(argp1);
24146 }
24147 {
24148 PyThreadState* __tstate = wxPyBeginAllowThreads();
24149 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24150 wxPyEndAllowThreads(__tstate);
24151 if (PyErr_Occurred()) SWIG_fail;
24152 }
24153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24154 return resultobj;
24155 fail:
24156 return NULL;
24157 }
24158
24159
24160 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24161 PyObject *resultobj = 0;
24162 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24163 wxWindow *result = 0 ;
24164 void *argp1 = 0 ;
24165 int res1 = 0 ;
24166 PyObject *swig_obj[1] ;
24167
24168 if (!args) SWIG_fail;
24169 swig_obj[0] = args;
24170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24171 if (!SWIG_IsOK(res1)) {
24172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24173 }
24174 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24175 {
24176 PyThreadState* __tstate = wxPyBeginAllowThreads();
24177 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24178 wxPyEndAllowThreads(__tstate);
24179 if (PyErr_Occurred()) SWIG_fail;
24180 }
24181 {
24182 resultobj = wxPyMake_wxObject(result, (bool)0);
24183 }
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24191 PyObject *obj;
24192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24193 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24194 return SWIG_Py_Void();
24195 }
24196
24197 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24198 return SWIG_Python_InitShadowInstance(args);
24199 }
24200
24201 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24202 PyObject *resultobj = 0;
24203 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24204 bool arg2 = (bool) true ;
24205 int arg3 = (int) 0 ;
24206 wxActivateEvent *result = 0 ;
24207 int val1 ;
24208 int ecode1 = 0 ;
24209 bool val2 ;
24210 int ecode2 = 0 ;
24211 int val3 ;
24212 int ecode3 = 0 ;
24213 PyObject * obj0 = 0 ;
24214 PyObject * obj1 = 0 ;
24215 PyObject * obj2 = 0 ;
24216 char * kwnames[] = {
24217 (char *) "type",(char *) "active",(char *) "Id", NULL
24218 };
24219
24220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24221 if (obj0) {
24222 ecode1 = SWIG_AsVal_int(obj0, &val1);
24223 if (!SWIG_IsOK(ecode1)) {
24224 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24225 }
24226 arg1 = static_cast< wxEventType >(val1);
24227 }
24228 if (obj1) {
24229 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24230 if (!SWIG_IsOK(ecode2)) {
24231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24232 }
24233 arg2 = static_cast< bool >(val2);
24234 }
24235 if (obj2) {
24236 ecode3 = SWIG_AsVal_int(obj2, &val3);
24237 if (!SWIG_IsOK(ecode3)) {
24238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24239 }
24240 arg3 = static_cast< int >(val3);
24241 }
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24245 wxPyEndAllowThreads(__tstate);
24246 if (PyErr_Occurred()) SWIG_fail;
24247 }
24248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24256 PyObject *resultobj = 0;
24257 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24258 bool result;
24259 void *argp1 = 0 ;
24260 int res1 = 0 ;
24261 PyObject *swig_obj[1] ;
24262
24263 if (!args) SWIG_fail;
24264 swig_obj[0] = args;
24265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24266 if (!SWIG_IsOK(res1)) {
24267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24268 }
24269 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24273 wxPyEndAllowThreads(__tstate);
24274 if (PyErr_Occurred()) SWIG_fail;
24275 }
24276 {
24277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24278 }
24279 return resultobj;
24280 fail:
24281 return NULL;
24282 }
24283
24284
24285 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24286 PyObject *obj;
24287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24288 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24289 return SWIG_Py_Void();
24290 }
24291
24292 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24293 return SWIG_Python_InitShadowInstance(args);
24294 }
24295
24296 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj = 0;
24298 int arg1 = (int) 0 ;
24299 wxInitDialogEvent *result = 0 ;
24300 int val1 ;
24301 int ecode1 = 0 ;
24302 PyObject * obj0 = 0 ;
24303 char * kwnames[] = {
24304 (char *) "Id", NULL
24305 };
24306
24307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24308 if (obj0) {
24309 ecode1 = SWIG_AsVal_int(obj0, &val1);
24310 if (!SWIG_IsOK(ecode1)) {
24311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24312 }
24313 arg1 = static_cast< int >(val1);
24314 }
24315 {
24316 PyThreadState* __tstate = wxPyBeginAllowThreads();
24317 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24318 wxPyEndAllowThreads(__tstate);
24319 if (PyErr_Occurred()) SWIG_fail;
24320 }
24321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24322 return resultobj;
24323 fail:
24324 return NULL;
24325 }
24326
24327
24328 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24329 PyObject *obj;
24330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24331 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24332 return SWIG_Py_Void();
24333 }
24334
24335 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 return SWIG_Python_InitShadowInstance(args);
24337 }
24338
24339 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24340 PyObject *resultobj = 0;
24341 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24342 int arg2 = (int) 0 ;
24343 wxMenu *arg3 = (wxMenu *) NULL ;
24344 wxMenuEvent *result = 0 ;
24345 int val1 ;
24346 int ecode1 = 0 ;
24347 int val2 ;
24348 int ecode2 = 0 ;
24349 void *argp3 = 0 ;
24350 int res3 = 0 ;
24351 PyObject * obj0 = 0 ;
24352 PyObject * obj1 = 0 ;
24353 PyObject * obj2 = 0 ;
24354 char * kwnames[] = {
24355 (char *) "type",(char *) "winid",(char *) "menu", NULL
24356 };
24357
24358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24359 if (obj0) {
24360 ecode1 = SWIG_AsVal_int(obj0, &val1);
24361 if (!SWIG_IsOK(ecode1)) {
24362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24363 }
24364 arg1 = static_cast< wxEventType >(val1);
24365 }
24366 if (obj1) {
24367 ecode2 = SWIG_AsVal_int(obj1, &val2);
24368 if (!SWIG_IsOK(ecode2)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24370 }
24371 arg2 = static_cast< int >(val2);
24372 }
24373 if (obj2) {
24374 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24375 if (!SWIG_IsOK(res3)) {
24376 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24377 }
24378 arg3 = reinterpret_cast< wxMenu * >(argp3);
24379 }
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 PyObject *resultobj = 0;
24395 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24396 int result;
24397 void *argp1 = 0 ;
24398 int res1 = 0 ;
24399 PyObject *swig_obj[1] ;
24400
24401 if (!args) SWIG_fail;
24402 swig_obj[0] = args;
24403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24404 if (!SWIG_IsOK(res1)) {
24405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24406 }
24407 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24408 {
24409 PyThreadState* __tstate = wxPyBeginAllowThreads();
24410 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24411 wxPyEndAllowThreads(__tstate);
24412 if (PyErr_Occurred()) SWIG_fail;
24413 }
24414 resultobj = SWIG_From_int(static_cast< int >(result));
24415 return resultobj;
24416 fail:
24417 return NULL;
24418 }
24419
24420
24421 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24422 PyObject *resultobj = 0;
24423 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24424 bool result;
24425 void *argp1 = 0 ;
24426 int res1 = 0 ;
24427 PyObject *swig_obj[1] ;
24428
24429 if (!args) SWIG_fail;
24430 swig_obj[0] = args;
24431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24432 if (!SWIG_IsOK(res1)) {
24433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24434 }
24435 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24436 {
24437 PyThreadState* __tstate = wxPyBeginAllowThreads();
24438 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24439 wxPyEndAllowThreads(__tstate);
24440 if (PyErr_Occurred()) SWIG_fail;
24441 }
24442 {
24443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24444 }
24445 return resultobj;
24446 fail:
24447 return NULL;
24448 }
24449
24450
24451 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24452 PyObject *resultobj = 0;
24453 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24454 wxMenu *result = 0 ;
24455 void *argp1 = 0 ;
24456 int res1 = 0 ;
24457 PyObject *swig_obj[1] ;
24458
24459 if (!args) SWIG_fail;
24460 swig_obj[0] = args;
24461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24462 if (!SWIG_IsOK(res1)) {
24463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24464 }
24465 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24466 {
24467 PyThreadState* __tstate = wxPyBeginAllowThreads();
24468 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 {
24473 resultobj = wxPyMake_wxObject(result, (bool)0);
24474 }
24475 return resultobj;
24476 fail:
24477 return NULL;
24478 }
24479
24480
24481 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24482 PyObject *obj;
24483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24484 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24485 return SWIG_Py_Void();
24486 }
24487
24488 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 return SWIG_Python_InitShadowInstance(args);
24490 }
24491
24492 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24493 PyObject *resultobj = 0;
24494 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24495 int arg2 = (int) 0 ;
24496 wxCloseEvent *result = 0 ;
24497 int val1 ;
24498 int ecode1 = 0 ;
24499 int val2 ;
24500 int ecode2 = 0 ;
24501 PyObject * obj0 = 0 ;
24502 PyObject * obj1 = 0 ;
24503 char * kwnames[] = {
24504 (char *) "type",(char *) "winid", NULL
24505 };
24506
24507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24508 if (obj0) {
24509 ecode1 = SWIG_AsVal_int(obj0, &val1);
24510 if (!SWIG_IsOK(ecode1)) {
24511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24512 }
24513 arg1 = static_cast< wxEventType >(val1);
24514 }
24515 if (obj1) {
24516 ecode2 = SWIG_AsVal_int(obj1, &val2);
24517 if (!SWIG_IsOK(ecode2)) {
24518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24519 }
24520 arg2 = static_cast< int >(val2);
24521 }
24522 {
24523 PyThreadState* __tstate = wxPyBeginAllowThreads();
24524 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24536 PyObject *resultobj = 0;
24537 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24538 bool arg2 ;
24539 void *argp1 = 0 ;
24540 int res1 = 0 ;
24541 bool val2 ;
24542 int ecode2 = 0 ;
24543 PyObject * obj0 = 0 ;
24544 PyObject * obj1 = 0 ;
24545 char * kwnames[] = {
24546 (char *) "self",(char *) "logOff", NULL
24547 };
24548
24549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24551 if (!SWIG_IsOK(res1)) {
24552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24553 }
24554 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24556 if (!SWIG_IsOK(ecode2)) {
24557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24558 }
24559 arg2 = static_cast< bool >(val2);
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 (arg1)->SetLoggingOff(arg2);
24563 wxPyEndAllowThreads(__tstate);
24564 if (PyErr_Occurred()) SWIG_fail;
24565 }
24566 resultobj = SWIG_Py_Void();
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24574 PyObject *resultobj = 0;
24575 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24576 bool result;
24577 void *argp1 = 0 ;
24578 int res1 = 0 ;
24579 PyObject *swig_obj[1] ;
24580
24581 if (!args) SWIG_fail;
24582 swig_obj[0] = args;
24583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24584 if (!SWIG_IsOK(res1)) {
24585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24586 }
24587 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24588 {
24589 PyThreadState* __tstate = wxPyBeginAllowThreads();
24590 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24591 wxPyEndAllowThreads(__tstate);
24592 if (PyErr_Occurred()) SWIG_fail;
24593 }
24594 {
24595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24596 }
24597 return resultobj;
24598 fail:
24599 return NULL;
24600 }
24601
24602
24603 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj = 0;
24605 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24606 bool arg2 = (bool) true ;
24607 void *argp1 = 0 ;
24608 int res1 = 0 ;
24609 bool val2 ;
24610 int ecode2 = 0 ;
24611 PyObject * obj0 = 0 ;
24612 PyObject * obj1 = 0 ;
24613 char * kwnames[] = {
24614 (char *) "self",(char *) "veto", NULL
24615 };
24616
24617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24619 if (!SWIG_IsOK(res1)) {
24620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24621 }
24622 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24623 if (obj1) {
24624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24625 if (!SWIG_IsOK(ecode2)) {
24626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24627 }
24628 arg2 = static_cast< bool >(val2);
24629 }
24630 {
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 (arg1)->Veto(arg2);
24633 wxPyEndAllowThreads(__tstate);
24634 if (PyErr_Occurred()) SWIG_fail;
24635 }
24636 resultobj = SWIG_Py_Void();
24637 return resultobj;
24638 fail:
24639 return NULL;
24640 }
24641
24642
24643 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24644 PyObject *resultobj = 0;
24645 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24646 bool result;
24647 void *argp1 = 0 ;
24648 int res1 = 0 ;
24649 PyObject *swig_obj[1] ;
24650
24651 if (!args) SWIG_fail;
24652 swig_obj[0] = args;
24653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24654 if (!SWIG_IsOK(res1)) {
24655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24656 }
24657 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24658 {
24659 PyThreadState* __tstate = wxPyBeginAllowThreads();
24660 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24661 wxPyEndAllowThreads(__tstate);
24662 if (PyErr_Occurred()) SWIG_fail;
24663 }
24664 {
24665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24666 }
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24674 PyObject *resultobj = 0;
24675 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24676 bool arg2 ;
24677 void *argp1 = 0 ;
24678 int res1 = 0 ;
24679 bool val2 ;
24680 int ecode2 = 0 ;
24681 PyObject * obj0 = 0 ;
24682 PyObject * obj1 = 0 ;
24683 char * kwnames[] = {
24684 (char *) "self",(char *) "canVeto", NULL
24685 };
24686
24687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24689 if (!SWIG_IsOK(res1)) {
24690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24691 }
24692 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24693 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24694 if (!SWIG_IsOK(ecode2)) {
24695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24696 }
24697 arg2 = static_cast< bool >(val2);
24698 {
24699 PyThreadState* __tstate = wxPyBeginAllowThreads();
24700 (arg1)->SetCanVeto(arg2);
24701 wxPyEndAllowThreads(__tstate);
24702 if (PyErr_Occurred()) SWIG_fail;
24703 }
24704 resultobj = SWIG_Py_Void();
24705 return resultobj;
24706 fail:
24707 return NULL;
24708 }
24709
24710
24711 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24712 PyObject *resultobj = 0;
24713 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24714 bool result;
24715 void *argp1 = 0 ;
24716 int res1 = 0 ;
24717 PyObject *swig_obj[1] ;
24718
24719 if (!args) SWIG_fail;
24720 swig_obj[0] = args;
24721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24722 if (!SWIG_IsOK(res1)) {
24723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24724 }
24725 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 {
24733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24734 }
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24742 PyObject *obj;
24743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24744 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24745 return SWIG_Py_Void();
24746 }
24747
24748 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749 return SWIG_Python_InitShadowInstance(args);
24750 }
24751
24752 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24753 PyObject *resultobj = 0;
24754 int arg1 = (int) 0 ;
24755 bool arg2 = (bool) false ;
24756 wxShowEvent *result = 0 ;
24757 int val1 ;
24758 int ecode1 = 0 ;
24759 bool val2 ;
24760 int ecode2 = 0 ;
24761 PyObject * obj0 = 0 ;
24762 PyObject * obj1 = 0 ;
24763 char * kwnames[] = {
24764 (char *) "winid",(char *) "show", NULL
24765 };
24766
24767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24768 if (obj0) {
24769 ecode1 = SWIG_AsVal_int(obj0, &val1);
24770 if (!SWIG_IsOK(ecode1)) {
24771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24772 }
24773 arg1 = static_cast< int >(val1);
24774 }
24775 if (obj1) {
24776 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24777 if (!SWIG_IsOK(ecode2)) {
24778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24779 }
24780 arg2 = static_cast< bool >(val2);
24781 }
24782 {
24783 PyThreadState* __tstate = wxPyBeginAllowThreads();
24784 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24785 wxPyEndAllowThreads(__tstate);
24786 if (PyErr_Occurred()) SWIG_fail;
24787 }
24788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24789 return resultobj;
24790 fail:
24791 return NULL;
24792 }
24793
24794
24795 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24796 PyObject *resultobj = 0;
24797 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24798 bool arg2 ;
24799 void *argp1 = 0 ;
24800 int res1 = 0 ;
24801 bool val2 ;
24802 int ecode2 = 0 ;
24803 PyObject * obj0 = 0 ;
24804 PyObject * obj1 = 0 ;
24805 char * kwnames[] = {
24806 (char *) "self",(char *) "show", NULL
24807 };
24808
24809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24811 if (!SWIG_IsOK(res1)) {
24812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24813 }
24814 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24815 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24816 if (!SWIG_IsOK(ecode2)) {
24817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24818 }
24819 arg2 = static_cast< bool >(val2);
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 (arg1)->SetShow(arg2);
24823 wxPyEndAllowThreads(__tstate);
24824 if (PyErr_Occurred()) SWIG_fail;
24825 }
24826 resultobj = SWIG_Py_Void();
24827 return resultobj;
24828 fail:
24829 return NULL;
24830 }
24831
24832
24833 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24834 PyObject *resultobj = 0;
24835 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24836 bool result;
24837 void *argp1 = 0 ;
24838 int res1 = 0 ;
24839 PyObject *swig_obj[1] ;
24840
24841 if (!args) SWIG_fail;
24842 swig_obj[0] = args;
24843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24844 if (!SWIG_IsOK(res1)) {
24845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24846 }
24847 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24851 wxPyEndAllowThreads(__tstate);
24852 if (PyErr_Occurred()) SWIG_fail;
24853 }
24854 {
24855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24856 }
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24864 PyObject *obj;
24865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24866 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24867 return SWIG_Py_Void();
24868 }
24869
24870 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24871 return SWIG_Python_InitShadowInstance(args);
24872 }
24873
24874 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24875 PyObject *resultobj = 0;
24876 int arg1 = (int) 0 ;
24877 bool arg2 = (bool) true ;
24878 wxIconizeEvent *result = 0 ;
24879 int val1 ;
24880 int ecode1 = 0 ;
24881 bool val2 ;
24882 int ecode2 = 0 ;
24883 PyObject * obj0 = 0 ;
24884 PyObject * obj1 = 0 ;
24885 char * kwnames[] = {
24886 (char *) "id",(char *) "iconized", NULL
24887 };
24888
24889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24890 if (obj0) {
24891 ecode1 = SWIG_AsVal_int(obj0, &val1);
24892 if (!SWIG_IsOK(ecode1)) {
24893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24894 }
24895 arg1 = static_cast< int >(val1);
24896 }
24897 if (obj1) {
24898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24899 if (!SWIG_IsOK(ecode2)) {
24900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24901 }
24902 arg2 = static_cast< bool >(val2);
24903 }
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *resultobj = 0;
24919 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24920 bool result;
24921 void *argp1 = 0 ;
24922 int res1 = 0 ;
24923 PyObject *swig_obj[1] ;
24924
24925 if (!args) SWIG_fail;
24926 swig_obj[0] = args;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (bool)(arg1)->Iconized();
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 {
24939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24940 }
24941 return resultobj;
24942 fail:
24943 return NULL;
24944 }
24945
24946
24947 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24948 PyObject *obj;
24949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24950 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24951 return SWIG_Py_Void();
24952 }
24953
24954 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24955 return SWIG_Python_InitShadowInstance(args);
24956 }
24957
24958 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24959 PyObject *resultobj = 0;
24960 int arg1 = (int) 0 ;
24961 wxMaximizeEvent *result = 0 ;
24962 int val1 ;
24963 int ecode1 = 0 ;
24964 PyObject * obj0 = 0 ;
24965 char * kwnames[] = {
24966 (char *) "id", NULL
24967 };
24968
24969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24970 if (obj0) {
24971 ecode1 = SWIG_AsVal_int(obj0, &val1);
24972 if (!SWIG_IsOK(ecode1)) {
24973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24974 }
24975 arg1 = static_cast< int >(val1);
24976 }
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24991 PyObject *obj;
24992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24993 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24994 return SWIG_Py_Void();
24995 }
24996
24997 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24998 return SWIG_Python_InitShadowInstance(args);
24999 }
25000
25001 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25002 PyObject *resultobj = 0;
25003 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25004 wxPoint result;
25005 void *argp1 = 0 ;
25006 int res1 = 0 ;
25007 PyObject *swig_obj[1] ;
25008
25009 if (!args) SWIG_fail;
25010 swig_obj[0] = args;
25011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25012 if (!SWIG_IsOK(res1)) {
25013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25014 }
25015 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25016 {
25017 PyThreadState* __tstate = wxPyBeginAllowThreads();
25018 result = (arg1)->GetPosition();
25019 wxPyEndAllowThreads(__tstate);
25020 if (PyErr_Occurred()) SWIG_fail;
25021 }
25022 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25030 PyObject *resultobj = 0;
25031 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25032 int 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_wxDropFilesEvent, 0 | 0 );
25040 if (!SWIG_IsOK(res1)) {
25041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25042 }
25043 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 result = (int)(arg1)->GetNumberOfFiles();
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 resultobj = SWIG_From_int(static_cast< int >(result));
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25058 PyObject *resultobj = 0;
25059 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25060 PyObject *result = 0 ;
25061 void *argp1 = 0 ;
25062 int res1 = 0 ;
25063 PyObject *swig_obj[1] ;
25064
25065 if (!args) SWIG_fail;
25066 swig_obj[0] = args;
25067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25068 if (!SWIG_IsOK(res1)) {
25069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25070 }
25071 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25072 {
25073 PyThreadState* __tstate = wxPyBeginAllowThreads();
25074 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 resultobj = result;
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25086 PyObject *obj;
25087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25088 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25089 return SWIG_Py_Void();
25090 }
25091
25092 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25093 PyObject *resultobj = 0;
25094 int arg1 = (int) 0 ;
25095 wxUpdateUIEvent *result = 0 ;
25096 int val1 ;
25097 int ecode1 = 0 ;
25098 PyObject * obj0 = 0 ;
25099 char * kwnames[] = {
25100 (char *) "commandId", NULL
25101 };
25102
25103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25104 if (obj0) {
25105 ecode1 = SWIG_AsVal_int(obj0, &val1);
25106 if (!SWIG_IsOK(ecode1)) {
25107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25108 }
25109 arg1 = static_cast< int >(val1);
25110 }
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25118 return resultobj;
25119 fail:
25120 return NULL;
25121 }
25122
25123
25124 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25125 PyObject *resultobj = 0;
25126 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25127 bool result;
25128 void *argp1 = 0 ;
25129 int res1 = 0 ;
25130 PyObject *swig_obj[1] ;
25131
25132 if (!args) SWIG_fail;
25133 swig_obj[0] = args;
25134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25135 if (!SWIG_IsOK(res1)) {
25136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25137 }
25138 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25139 {
25140 PyThreadState* __tstate = wxPyBeginAllowThreads();
25141 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25142 wxPyEndAllowThreads(__tstate);
25143 if (PyErr_Occurred()) SWIG_fail;
25144 }
25145 {
25146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25147 }
25148 return resultobj;
25149 fail:
25150 return NULL;
25151 }
25152
25153
25154 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25155 PyObject *resultobj = 0;
25156 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25157 bool result;
25158 void *argp1 = 0 ;
25159 int res1 = 0 ;
25160 PyObject *swig_obj[1] ;
25161
25162 if (!args) SWIG_fail;
25163 swig_obj[0] = args;
25164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25165 if (!SWIG_IsOK(res1)) {
25166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25167 }
25168 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25169 {
25170 PyThreadState* __tstate = wxPyBeginAllowThreads();
25171 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25172 wxPyEndAllowThreads(__tstate);
25173 if (PyErr_Occurred()) SWIG_fail;
25174 }
25175 {
25176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25177 }
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25185 PyObject *resultobj = 0;
25186 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25187 bool result;
25188 void *argp1 = 0 ;
25189 int res1 = 0 ;
25190 PyObject *swig_obj[1] ;
25191
25192 if (!args) SWIG_fail;
25193 swig_obj[0] = args;
25194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25195 if (!SWIG_IsOK(res1)) {
25196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25197 }
25198 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25202 wxPyEndAllowThreads(__tstate);
25203 if (PyErr_Occurred()) SWIG_fail;
25204 }
25205 {
25206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25207 }
25208 return resultobj;
25209 fail:
25210 return NULL;
25211 }
25212
25213
25214 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25215 PyObject *resultobj = 0;
25216 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25217 wxString result;
25218 void *argp1 = 0 ;
25219 int res1 = 0 ;
25220 PyObject *swig_obj[1] ;
25221
25222 if (!args) SWIG_fail;
25223 swig_obj[0] = args;
25224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25225 if (!SWIG_IsOK(res1)) {
25226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25227 }
25228 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25229 {
25230 PyThreadState* __tstate = wxPyBeginAllowThreads();
25231 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25232 wxPyEndAllowThreads(__tstate);
25233 if (PyErr_Occurred()) SWIG_fail;
25234 }
25235 {
25236 #if wxUSE_UNICODE
25237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25238 #else
25239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25240 #endif
25241 }
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 PyObject *resultobj = 0;
25250 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25251 bool result;
25252 void *argp1 = 0 ;
25253 int res1 = 0 ;
25254 PyObject *swig_obj[1] ;
25255
25256 if (!args) SWIG_fail;
25257 swig_obj[0] = args;
25258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25259 if (!SWIG_IsOK(res1)) {
25260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25261 }
25262 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25266 wxPyEndAllowThreads(__tstate);
25267 if (PyErr_Occurred()) SWIG_fail;
25268 }
25269 {
25270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25271 }
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25279 PyObject *resultobj = 0;
25280 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25281 bool result;
25282 void *argp1 = 0 ;
25283 int res1 = 0 ;
25284 PyObject *swig_obj[1] ;
25285
25286 if (!args) SWIG_fail;
25287 swig_obj[0] = args;
25288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25289 if (!SWIG_IsOK(res1)) {
25290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25291 }
25292 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 {
25300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25301 }
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25309 PyObject *resultobj = 0;
25310 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25311 bool result;
25312 void *argp1 = 0 ;
25313 int res1 = 0 ;
25314 PyObject *swig_obj[1] ;
25315
25316 if (!args) SWIG_fail;
25317 swig_obj[0] = args;
25318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25319 if (!SWIG_IsOK(res1)) {
25320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25321 }
25322 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 {
25330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25331 }
25332 return resultobj;
25333 fail:
25334 return NULL;
25335 }
25336
25337
25338 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25339 PyObject *resultobj = 0;
25340 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25341 bool result;
25342 void *argp1 = 0 ;
25343 int res1 = 0 ;
25344 PyObject *swig_obj[1] ;
25345
25346 if (!args) SWIG_fail;
25347 swig_obj[0] = args;
25348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25349 if (!SWIG_IsOK(res1)) {
25350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25351 }
25352 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25353 {
25354 PyThreadState* __tstate = wxPyBeginAllowThreads();
25355 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25356 wxPyEndAllowThreads(__tstate);
25357 if (PyErr_Occurred()) SWIG_fail;
25358 }
25359 {
25360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25361 }
25362 return resultobj;
25363 fail:
25364 return NULL;
25365 }
25366
25367
25368 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25369 PyObject *resultobj = 0;
25370 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25371 bool arg2 ;
25372 void *argp1 = 0 ;
25373 int res1 = 0 ;
25374 bool val2 ;
25375 int ecode2 = 0 ;
25376 PyObject * obj0 = 0 ;
25377 PyObject * obj1 = 0 ;
25378 char * kwnames[] = {
25379 (char *) "self",(char *) "check", NULL
25380 };
25381
25382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25384 if (!SWIG_IsOK(res1)) {
25385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25386 }
25387 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25388 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25389 if (!SWIG_IsOK(ecode2)) {
25390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25391 }
25392 arg2 = static_cast< bool >(val2);
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 (arg1)->Check(arg2);
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 resultobj = SWIG_Py_Void();
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25407 PyObject *resultobj = 0;
25408 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25409 bool arg2 ;
25410 void *argp1 = 0 ;
25411 int res1 = 0 ;
25412 bool val2 ;
25413 int ecode2 = 0 ;
25414 PyObject * obj0 = 0 ;
25415 PyObject * obj1 = 0 ;
25416 char * kwnames[] = {
25417 (char *) "self",(char *) "enable", NULL
25418 };
25419
25420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25422 if (!SWIG_IsOK(res1)) {
25423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25424 }
25425 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25426 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25427 if (!SWIG_IsOK(ecode2)) {
25428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25429 }
25430 arg2 = static_cast< bool >(val2);
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 (arg1)->Enable(arg2);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_Py_Void();
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25445 PyObject *resultobj = 0;
25446 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25447 bool arg2 ;
25448 void *argp1 = 0 ;
25449 int res1 = 0 ;
25450 bool val2 ;
25451 int ecode2 = 0 ;
25452 PyObject * obj0 = 0 ;
25453 PyObject * obj1 = 0 ;
25454 char * kwnames[] = {
25455 (char *) "self",(char *) "show", NULL
25456 };
25457
25458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25460 if (!SWIG_IsOK(res1)) {
25461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25462 }
25463 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25464 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25465 if (!SWIG_IsOK(ecode2)) {
25466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25467 }
25468 arg2 = static_cast< bool >(val2);
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 (arg1)->Show(arg2);
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 resultobj = SWIG_Py_Void();
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25483 PyObject *resultobj = 0;
25484 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25485 wxString *arg2 = 0 ;
25486 void *argp1 = 0 ;
25487 int res1 = 0 ;
25488 bool temp2 = false ;
25489 PyObject * obj0 = 0 ;
25490 PyObject * obj1 = 0 ;
25491 char * kwnames[] = {
25492 (char *) "self",(char *) "text", NULL
25493 };
25494
25495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25497 if (!SWIG_IsOK(res1)) {
25498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25499 }
25500 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25501 {
25502 arg2 = wxString_in_helper(obj1);
25503 if (arg2 == NULL) SWIG_fail;
25504 temp2 = true;
25505 }
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 (arg1)->SetText((wxString const &)*arg2);
25509 wxPyEndAllowThreads(__tstate);
25510 if (PyErr_Occurred()) SWIG_fail;
25511 }
25512 resultobj = SWIG_Py_Void();
25513 {
25514 if (temp2)
25515 delete arg2;
25516 }
25517 return resultobj;
25518 fail:
25519 {
25520 if (temp2)
25521 delete arg2;
25522 }
25523 return NULL;
25524 }
25525
25526
25527 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj = 0;
25529 long arg1 ;
25530 long val1 ;
25531 int ecode1 = 0 ;
25532 PyObject * obj0 = 0 ;
25533 char * kwnames[] = {
25534 (char *) "updateInterval", NULL
25535 };
25536
25537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25538 ecode1 = SWIG_AsVal_long(obj0, &val1);
25539 if (!SWIG_IsOK(ecode1)) {
25540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25541 }
25542 arg1 = static_cast< long >(val1);
25543 {
25544 PyThreadState* __tstate = wxPyBeginAllowThreads();
25545 wxUpdateUIEvent::SetUpdateInterval(arg1);
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 resultobj = SWIG_Py_Void();
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 PyObject *resultobj = 0;
25558 long result;
25559
25560 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 resultobj = SWIG_From_long(static_cast< long >(result));
25568 return resultobj;
25569 fail:
25570 return NULL;
25571 }
25572
25573
25574 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25575 PyObject *resultobj = 0;
25576 wxWindow *arg1 = (wxWindow *) 0 ;
25577 bool result;
25578 void *argp1 = 0 ;
25579 int res1 = 0 ;
25580 PyObject * obj0 = 0 ;
25581 char * kwnames[] = {
25582 (char *) "win", NULL
25583 };
25584
25585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25587 if (!SWIG_IsOK(res1)) {
25588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25589 }
25590 arg1 = reinterpret_cast< wxWindow * >(argp1);
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25594 wxPyEndAllowThreads(__tstate);
25595 if (PyErr_Occurred()) SWIG_fail;
25596 }
25597 {
25598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25599 }
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25607 PyObject *resultobj = 0;
25608
25609 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25610 {
25611 PyThreadState* __tstate = wxPyBeginAllowThreads();
25612 wxUpdateUIEvent::ResetUpdateTime();
25613 wxPyEndAllowThreads(__tstate);
25614 if (PyErr_Occurred()) SWIG_fail;
25615 }
25616 resultobj = SWIG_Py_Void();
25617 return resultobj;
25618 fail:
25619 return NULL;
25620 }
25621
25622
25623 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25624 PyObject *resultobj = 0;
25625 wxUpdateUIMode arg1 ;
25626 int val1 ;
25627 int ecode1 = 0 ;
25628 PyObject * obj0 = 0 ;
25629 char * kwnames[] = {
25630 (char *) "mode", NULL
25631 };
25632
25633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25634 ecode1 = SWIG_AsVal_int(obj0, &val1);
25635 if (!SWIG_IsOK(ecode1)) {
25636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25637 }
25638 arg1 = static_cast< wxUpdateUIMode >(val1);
25639 {
25640 PyThreadState* __tstate = wxPyBeginAllowThreads();
25641 wxUpdateUIEvent::SetMode(arg1);
25642 wxPyEndAllowThreads(__tstate);
25643 if (PyErr_Occurred()) SWIG_fail;
25644 }
25645 resultobj = SWIG_Py_Void();
25646 return resultobj;
25647 fail:
25648 return NULL;
25649 }
25650
25651
25652 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25653 PyObject *resultobj = 0;
25654 wxUpdateUIMode result;
25655
25656 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25657 {
25658 PyThreadState* __tstate = wxPyBeginAllowThreads();
25659 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25660 wxPyEndAllowThreads(__tstate);
25661 if (PyErr_Occurred()) SWIG_fail;
25662 }
25663 resultobj = SWIG_From_int(static_cast< int >(result));
25664 return resultobj;
25665 fail:
25666 return NULL;
25667 }
25668
25669
25670 SWIGINTERN PyObject *UpdateUIEvent_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_wxUpdateUIEvent, SWIG_NewClientData(obj));
25674 return SWIG_Py_Void();
25675 }
25676
25677 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25678 return SWIG_Python_InitShadowInstance(args);
25679 }
25680
25681 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25682 PyObject *resultobj = 0;
25683 wxSysColourChangedEvent *result = 0 ;
25684
25685 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25689 wxPyEndAllowThreads(__tstate);
25690 if (PyErr_Occurred()) SWIG_fail;
25691 }
25692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25693 return resultobj;
25694 fail:
25695 return NULL;
25696 }
25697
25698
25699 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25700 PyObject *obj;
25701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25702 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25703 return SWIG_Py_Void();
25704 }
25705
25706 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25707 return SWIG_Python_InitShadowInstance(args);
25708 }
25709
25710 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj = 0;
25712 int arg1 = (int) 0 ;
25713 wxWindow *arg2 = (wxWindow *) NULL ;
25714 wxMouseCaptureChangedEvent *result = 0 ;
25715 int val1 ;
25716 int ecode1 = 0 ;
25717 void *argp2 = 0 ;
25718 int res2 = 0 ;
25719 PyObject * obj0 = 0 ;
25720 PyObject * obj1 = 0 ;
25721 char * kwnames[] = {
25722 (char *) "winid",(char *) "gainedCapture", NULL
25723 };
25724
25725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25726 if (obj0) {
25727 ecode1 = SWIG_AsVal_int(obj0, &val1);
25728 if (!SWIG_IsOK(ecode1)) {
25729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25730 }
25731 arg1 = static_cast< int >(val1);
25732 }
25733 if (obj1) {
25734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25735 if (!SWIG_IsOK(res2)) {
25736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25737 }
25738 arg2 = reinterpret_cast< wxWindow * >(argp2);
25739 }
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25743 wxPyEndAllowThreads(__tstate);
25744 if (PyErr_Occurred()) SWIG_fail;
25745 }
25746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *resultobj = 0;
25755 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25756 wxWindow *result = 0 ;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 PyObject *swig_obj[1] ;
25760
25761 if (!args) SWIG_fail;
25762 swig_obj[0] = args;
25763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25764 if (!SWIG_IsOK(res1)) {
25765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25766 }
25767 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 {
25775 resultobj = wxPyMake_wxObject(result, (bool)0);
25776 }
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25784 PyObject *obj;
25785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25786 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25787 return SWIG_Py_Void();
25788 }
25789
25790 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25791 return SWIG_Python_InitShadowInstance(args);
25792 }
25793
25794 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj = 0;
25796 int arg1 = (int) 0 ;
25797 wxMouseCaptureLostEvent *result = 0 ;
25798 int val1 ;
25799 int ecode1 = 0 ;
25800 PyObject * obj0 = 0 ;
25801 char * kwnames[] = {
25802 (char *) "winid", NULL
25803 };
25804
25805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25806 if (obj0) {
25807 ecode1 = SWIG_AsVal_int(obj0, &val1);
25808 if (!SWIG_IsOK(ecode1)) {
25809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25810 }
25811 arg1 = static_cast< int >(val1);
25812 }
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25827 PyObject *obj;
25828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25829 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25830 return SWIG_Py_Void();
25831 }
25832
25833 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25834 return SWIG_Python_InitShadowInstance(args);
25835 }
25836
25837 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25838 PyObject *resultobj = 0;
25839 wxDisplayChangedEvent *result = 0 ;
25840
25841 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25856 PyObject *obj;
25857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25858 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25859 return SWIG_Py_Void();
25860 }
25861
25862 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25863 return SWIG_Python_InitShadowInstance(args);
25864 }
25865
25866 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25867 PyObject *resultobj = 0;
25868 int arg1 = (int) 0 ;
25869 wxPaletteChangedEvent *result = 0 ;
25870 int val1 ;
25871 int ecode1 = 0 ;
25872 PyObject * obj0 = 0 ;
25873 char * kwnames[] = {
25874 (char *) "id", NULL
25875 };
25876
25877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25878 if (obj0) {
25879 ecode1 = SWIG_AsVal_int(obj0, &val1);
25880 if (!SWIG_IsOK(ecode1)) {
25881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25882 }
25883 arg1 = static_cast< int >(val1);
25884 }
25885 {
25886 PyThreadState* __tstate = wxPyBeginAllowThreads();
25887 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25888 wxPyEndAllowThreads(__tstate);
25889 if (PyErr_Occurred()) SWIG_fail;
25890 }
25891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25892 return resultobj;
25893 fail:
25894 return NULL;
25895 }
25896
25897
25898 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25899 PyObject *resultobj = 0;
25900 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25901 wxWindow *arg2 = (wxWindow *) 0 ;
25902 void *argp1 = 0 ;
25903 int res1 = 0 ;
25904 void *argp2 = 0 ;
25905 int res2 = 0 ;
25906 PyObject * obj0 = 0 ;
25907 PyObject * obj1 = 0 ;
25908 char * kwnames[] = {
25909 (char *) "self",(char *) "win", NULL
25910 };
25911
25912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25914 if (!SWIG_IsOK(res1)) {
25915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25916 }
25917 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25918 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25919 if (!SWIG_IsOK(res2)) {
25920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25921 }
25922 arg2 = reinterpret_cast< wxWindow * >(argp2);
25923 {
25924 PyThreadState* __tstate = wxPyBeginAllowThreads();
25925 (arg1)->SetChangedWindow(arg2);
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_Py_Void();
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25937 PyObject *resultobj = 0;
25938 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25939 wxWindow *result = 0 ;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 PyObject *swig_obj[1] ;
25943
25944 if (!args) SWIG_fail;
25945 swig_obj[0] = args;
25946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25947 if (!SWIG_IsOK(res1)) {
25948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25949 }
25950 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 result = (wxWindow *)(arg1)->GetChangedWindow();
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 {
25958 resultobj = wxPyMake_wxObject(result, (bool)0);
25959 }
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25967 PyObject *obj;
25968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25969 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25970 return SWIG_Py_Void();
25971 }
25972
25973 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25974 return SWIG_Python_InitShadowInstance(args);
25975 }
25976
25977 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25978 PyObject *resultobj = 0;
25979 int arg1 = (int) 0 ;
25980 wxQueryNewPaletteEvent *result = 0 ;
25981 int val1 ;
25982 int ecode1 = 0 ;
25983 PyObject * obj0 = 0 ;
25984 char * kwnames[] = {
25985 (char *) "winid", NULL
25986 };
25987
25988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25989 if (obj0) {
25990 ecode1 = SWIG_AsVal_int(obj0, &val1);
25991 if (!SWIG_IsOK(ecode1)) {
25992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25993 }
25994 arg1 = static_cast< int >(val1);
25995 }
25996 {
25997 PyThreadState* __tstate = wxPyBeginAllowThreads();
25998 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25999 wxPyEndAllowThreads(__tstate);
26000 if (PyErr_Occurred()) SWIG_fail;
26001 }
26002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26010 PyObject *resultobj = 0;
26011 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26012 bool arg2 ;
26013 void *argp1 = 0 ;
26014 int res1 = 0 ;
26015 bool val2 ;
26016 int ecode2 = 0 ;
26017 PyObject * obj0 = 0 ;
26018 PyObject * obj1 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "self",(char *) "realized", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26027 }
26028 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26030 if (!SWIG_IsOK(ecode2)) {
26031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26032 }
26033 arg2 = static_cast< bool >(val2);
26034 {
26035 PyThreadState* __tstate = wxPyBeginAllowThreads();
26036 (arg1)->SetPaletteRealized(arg2);
26037 wxPyEndAllowThreads(__tstate);
26038 if (PyErr_Occurred()) SWIG_fail;
26039 }
26040 resultobj = SWIG_Py_Void();
26041 return resultobj;
26042 fail:
26043 return NULL;
26044 }
26045
26046
26047 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26048 PyObject *resultobj = 0;
26049 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26050 bool result;
26051 void *argp1 = 0 ;
26052 int res1 = 0 ;
26053 PyObject *swig_obj[1] ;
26054
26055 if (!args) SWIG_fail;
26056 swig_obj[0] = args;
26057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26058 if (!SWIG_IsOK(res1)) {
26059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26060 }
26061 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26062 {
26063 PyThreadState* __tstate = wxPyBeginAllowThreads();
26064 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26065 wxPyEndAllowThreads(__tstate);
26066 if (PyErr_Occurred()) SWIG_fail;
26067 }
26068 {
26069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26070 }
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26078 PyObject *obj;
26079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26080 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26081 return SWIG_Py_Void();
26082 }
26083
26084 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26085 return SWIG_Python_InitShadowInstance(args);
26086 }
26087
26088 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26089 PyObject *resultobj = 0;
26090 wxNavigationKeyEvent *result = 0 ;
26091
26092 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26093 {
26094 PyThreadState* __tstate = wxPyBeginAllowThreads();
26095 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26096 wxPyEndAllowThreads(__tstate);
26097 if (PyErr_Occurred()) SWIG_fail;
26098 }
26099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26107 PyObject *resultobj = 0;
26108 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26109 bool result;
26110 void *argp1 = 0 ;
26111 int res1 = 0 ;
26112 PyObject *swig_obj[1] ;
26113
26114 if (!args) SWIG_fail;
26115 swig_obj[0] = args;
26116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26119 }
26120 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 {
26128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26129 }
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj = 0;
26138 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26139 bool arg2 ;
26140 void *argp1 = 0 ;
26141 int res1 = 0 ;
26142 bool val2 ;
26143 int ecode2 = 0 ;
26144 PyObject * obj0 = 0 ;
26145 PyObject * obj1 = 0 ;
26146 char * kwnames[] = {
26147 (char *) "self",(char *) "forward", NULL
26148 };
26149
26150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26152 if (!SWIG_IsOK(res1)) {
26153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26154 }
26155 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26157 if (!SWIG_IsOK(ecode2)) {
26158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26159 }
26160 arg2 = static_cast< bool >(val2);
26161 {
26162 PyThreadState* __tstate = wxPyBeginAllowThreads();
26163 (arg1)->SetDirection(arg2);
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_Py_Void();
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26175 PyObject *resultobj = 0;
26176 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26177 bool result;
26178 void *argp1 = 0 ;
26179 int res1 = 0 ;
26180 PyObject *swig_obj[1] ;
26181
26182 if (!args) SWIG_fail;
26183 swig_obj[0] = args;
26184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26185 if (!SWIG_IsOK(res1)) {
26186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26187 }
26188 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26189 {
26190 PyThreadState* __tstate = wxPyBeginAllowThreads();
26191 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26192 wxPyEndAllowThreads(__tstate);
26193 if (PyErr_Occurred()) SWIG_fail;
26194 }
26195 {
26196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26197 }
26198 return resultobj;
26199 fail:
26200 return NULL;
26201 }
26202
26203
26204 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26205 PyObject *resultobj = 0;
26206 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26207 bool arg2 ;
26208 void *argp1 = 0 ;
26209 int res1 = 0 ;
26210 bool val2 ;
26211 int ecode2 = 0 ;
26212 PyObject * obj0 = 0 ;
26213 PyObject * obj1 = 0 ;
26214 char * kwnames[] = {
26215 (char *) "self",(char *) "ischange", NULL
26216 };
26217
26218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26220 if (!SWIG_IsOK(res1)) {
26221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26222 }
26223 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26225 if (!SWIG_IsOK(ecode2)) {
26226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26227 }
26228 arg2 = static_cast< bool >(val2);
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 (arg1)->SetWindowChange(arg2);
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_Py_Void();
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26243 PyObject *resultobj = 0;
26244 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26245 bool result;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 PyObject *swig_obj[1] ;
26249
26250 if (!args) SWIG_fail;
26251 swig_obj[0] = args;
26252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26255 }
26256 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 {
26264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26265 }
26266 return resultobj;
26267 fail:
26268 return NULL;
26269 }
26270
26271
26272 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26273 PyObject *resultobj = 0;
26274 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26275 bool arg2 ;
26276 void *argp1 = 0 ;
26277 int res1 = 0 ;
26278 bool val2 ;
26279 int ecode2 = 0 ;
26280 PyObject * obj0 = 0 ;
26281 PyObject * obj1 = 0 ;
26282 char * kwnames[] = {
26283 (char *) "self",(char *) "bIs", NULL
26284 };
26285
26286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26288 if (!SWIG_IsOK(res1)) {
26289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26290 }
26291 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26293 if (!SWIG_IsOK(ecode2)) {
26294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26295 }
26296 arg2 = static_cast< bool >(val2);
26297 {
26298 PyThreadState* __tstate = wxPyBeginAllowThreads();
26299 (arg1)->SetFromTab(arg2);
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 resultobj = SWIG_Py_Void();
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26311 PyObject *resultobj = 0;
26312 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26313 long arg2 ;
26314 void *argp1 = 0 ;
26315 int res1 = 0 ;
26316 long val2 ;
26317 int ecode2 = 0 ;
26318 PyObject * obj0 = 0 ;
26319 PyObject * obj1 = 0 ;
26320 char * kwnames[] = {
26321 (char *) "self",(char *) "flags", NULL
26322 };
26323
26324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26326 if (!SWIG_IsOK(res1)) {
26327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26328 }
26329 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26330 ecode2 = SWIG_AsVal_long(obj1, &val2);
26331 if (!SWIG_IsOK(ecode2)) {
26332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26333 }
26334 arg2 = static_cast< long >(val2);
26335 {
26336 PyThreadState* __tstate = wxPyBeginAllowThreads();
26337 (arg1)->SetFlags(arg2);
26338 wxPyEndAllowThreads(__tstate);
26339 if (PyErr_Occurred()) SWIG_fail;
26340 }
26341 resultobj = SWIG_Py_Void();
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26349 PyObject *resultobj = 0;
26350 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26351 wxWindow *result = 0 ;
26352 void *argp1 = 0 ;
26353 int res1 = 0 ;
26354 PyObject *swig_obj[1] ;
26355
26356 if (!args) SWIG_fail;
26357 swig_obj[0] = args;
26358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26359 if (!SWIG_IsOK(res1)) {
26360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26361 }
26362 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26366 wxPyEndAllowThreads(__tstate);
26367 if (PyErr_Occurred()) SWIG_fail;
26368 }
26369 {
26370 resultobj = wxPyMake_wxObject(result, (bool)0);
26371 }
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26379 PyObject *resultobj = 0;
26380 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26381 wxWindow *arg2 = (wxWindow *) 0 ;
26382 void *argp1 = 0 ;
26383 int res1 = 0 ;
26384 void *argp2 = 0 ;
26385 int res2 = 0 ;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char * kwnames[] = {
26389 (char *) "self",(char *) "win", NULL
26390 };
26391
26392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26394 if (!SWIG_IsOK(res1)) {
26395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26396 }
26397 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26399 if (!SWIG_IsOK(res2)) {
26400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26401 }
26402 arg2 = reinterpret_cast< wxWindow * >(argp2);
26403 {
26404 PyThreadState* __tstate = wxPyBeginAllowThreads();
26405 (arg1)->SetCurrentFocus(arg2);
26406 wxPyEndAllowThreads(__tstate);
26407 if (PyErr_Occurred()) SWIG_fail;
26408 }
26409 resultobj = SWIG_Py_Void();
26410 return resultobj;
26411 fail:
26412 return NULL;
26413 }
26414
26415
26416 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26417 PyObject *obj;
26418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26419 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26420 return SWIG_Py_Void();
26421 }
26422
26423 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26424 return SWIG_Python_InitShadowInstance(args);
26425 }
26426
26427 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj = 0;
26429 wxWindow *arg1 = (wxWindow *) NULL ;
26430 wxWindowCreateEvent *result = 0 ;
26431 void *argp1 = 0 ;
26432 int res1 = 0 ;
26433 PyObject * obj0 = 0 ;
26434 char * kwnames[] = {
26435 (char *) "win", NULL
26436 };
26437
26438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26439 if (obj0) {
26440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26441 if (!SWIG_IsOK(res1)) {
26442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26443 }
26444 arg1 = reinterpret_cast< wxWindow * >(argp1);
26445 }
26446 {
26447 PyThreadState* __tstate = wxPyBeginAllowThreads();
26448 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26449 wxPyEndAllowThreads(__tstate);
26450 if (PyErr_Occurred()) SWIG_fail;
26451 }
26452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26453 return resultobj;
26454 fail:
26455 return NULL;
26456 }
26457
26458
26459 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26460 PyObject *resultobj = 0;
26461 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26462 wxWindow *result = 0 ;
26463 void *argp1 = 0 ;
26464 int res1 = 0 ;
26465 PyObject *swig_obj[1] ;
26466
26467 if (!args) SWIG_fail;
26468 swig_obj[0] = args;
26469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26470 if (!SWIG_IsOK(res1)) {
26471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26472 }
26473 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26474 {
26475 PyThreadState* __tstate = wxPyBeginAllowThreads();
26476 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26477 wxPyEndAllowThreads(__tstate);
26478 if (PyErr_Occurred()) SWIG_fail;
26479 }
26480 {
26481 resultobj = wxPyMake_wxObject(result, (bool)0);
26482 }
26483 return resultobj;
26484 fail:
26485 return NULL;
26486 }
26487
26488
26489 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26490 PyObject *obj;
26491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26492 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26493 return SWIG_Py_Void();
26494 }
26495
26496 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26497 return SWIG_Python_InitShadowInstance(args);
26498 }
26499
26500 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj = 0;
26502 wxWindow *arg1 = (wxWindow *) NULL ;
26503 wxWindowDestroyEvent *result = 0 ;
26504 void *argp1 = 0 ;
26505 int res1 = 0 ;
26506 PyObject * obj0 = 0 ;
26507 char * kwnames[] = {
26508 (char *) "win", NULL
26509 };
26510
26511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26512 if (obj0) {
26513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26516 }
26517 arg1 = reinterpret_cast< wxWindow * >(argp1);
26518 }
26519 {
26520 PyThreadState* __tstate = wxPyBeginAllowThreads();
26521 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26526 return resultobj;
26527 fail:
26528 return NULL;
26529 }
26530
26531
26532 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26533 PyObject *resultobj = 0;
26534 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26535 wxWindow *result = 0 ;
26536 void *argp1 = 0 ;
26537 int res1 = 0 ;
26538 PyObject *swig_obj[1] ;
26539
26540 if (!args) SWIG_fail;
26541 swig_obj[0] = args;
26542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26543 if (!SWIG_IsOK(res1)) {
26544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26545 }
26546 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 {
26554 resultobj = wxPyMake_wxObject(result, (bool)0);
26555 }
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26563 PyObject *obj;
26564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26565 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26566 return SWIG_Py_Void();
26567 }
26568
26569 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26570 return SWIG_Python_InitShadowInstance(args);
26571 }
26572
26573 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26574 PyObject *resultobj = 0;
26575 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26576 int arg2 = (int) 0 ;
26577 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26578 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26579 wxContextMenuEvent *result = 0 ;
26580 int val1 ;
26581 int ecode1 = 0 ;
26582 int val2 ;
26583 int ecode2 = 0 ;
26584 wxPoint temp3 ;
26585 PyObject * obj0 = 0 ;
26586 PyObject * obj1 = 0 ;
26587 PyObject * obj2 = 0 ;
26588 char * kwnames[] = {
26589 (char *) "type",(char *) "winid",(char *) "pt", NULL
26590 };
26591
26592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26593 if (obj0) {
26594 ecode1 = SWIG_AsVal_int(obj0, &val1);
26595 if (!SWIG_IsOK(ecode1)) {
26596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26597 }
26598 arg1 = static_cast< wxEventType >(val1);
26599 }
26600 if (obj1) {
26601 ecode2 = SWIG_AsVal_int(obj1, &val2);
26602 if (!SWIG_IsOK(ecode2)) {
26603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26604 }
26605 arg2 = static_cast< int >(val2);
26606 }
26607 if (obj2) {
26608 {
26609 arg3 = &temp3;
26610 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26611 }
26612 }
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26616 wxPyEndAllowThreads(__tstate);
26617 if (PyErr_Occurred()) SWIG_fail;
26618 }
26619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26620 return resultobj;
26621 fail:
26622 return NULL;
26623 }
26624
26625
26626 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26627 PyObject *resultobj = 0;
26628 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26629 wxPoint *result = 0 ;
26630 void *argp1 = 0 ;
26631 int res1 = 0 ;
26632 PyObject *swig_obj[1] ;
26633
26634 if (!args) SWIG_fail;
26635 swig_obj[0] = args;
26636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26637 if (!SWIG_IsOK(res1)) {
26638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26639 }
26640 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 {
26644 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26645 result = (wxPoint *) &_result_ref;
26646 }
26647 wxPyEndAllowThreads(__tstate);
26648 if (PyErr_Occurred()) SWIG_fail;
26649 }
26650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26651 return resultobj;
26652 fail:
26653 return NULL;
26654 }
26655
26656
26657 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26658 PyObject *resultobj = 0;
26659 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26660 wxPoint *arg2 = 0 ;
26661 void *argp1 = 0 ;
26662 int res1 = 0 ;
26663 wxPoint temp2 ;
26664 PyObject * obj0 = 0 ;
26665 PyObject * obj1 = 0 ;
26666 char * kwnames[] = {
26667 (char *) "self",(char *) "pos", NULL
26668 };
26669
26670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26672 if (!SWIG_IsOK(res1)) {
26673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26674 }
26675 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26676 {
26677 arg2 = &temp2;
26678 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26679 }
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 (arg1)->SetPosition((wxPoint const &)*arg2);
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 resultobj = SWIG_Py_Void();
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26694 PyObject *obj;
26695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26696 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26697 return SWIG_Py_Void();
26698 }
26699
26700 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26701 return SWIG_Python_InitShadowInstance(args);
26702 }
26703
26704 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26705 PyObject *resultobj = 0;
26706 wxIdleEvent *result = 0 ;
26707
26708 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26709 {
26710 PyThreadState* __tstate = wxPyBeginAllowThreads();
26711 result = (wxIdleEvent *)new wxIdleEvent();
26712 wxPyEndAllowThreads(__tstate);
26713 if (PyErr_Occurred()) SWIG_fail;
26714 }
26715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26716 return resultobj;
26717 fail:
26718 return NULL;
26719 }
26720
26721
26722 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26723 PyObject *resultobj = 0;
26724 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26725 bool arg2 = (bool) true ;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 bool val2 ;
26729 int ecode2 = 0 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 char * kwnames[] = {
26733 (char *) "self",(char *) "needMore", NULL
26734 };
26735
26736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26738 if (!SWIG_IsOK(res1)) {
26739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26740 }
26741 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26742 if (obj1) {
26743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26744 if (!SWIG_IsOK(ecode2)) {
26745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26746 }
26747 arg2 = static_cast< bool >(val2);
26748 }
26749 {
26750 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 (arg1)->RequestMore(arg2);
26752 wxPyEndAllowThreads(__tstate);
26753 if (PyErr_Occurred()) SWIG_fail;
26754 }
26755 resultobj = SWIG_Py_Void();
26756 return resultobj;
26757 fail:
26758 return NULL;
26759 }
26760
26761
26762 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26763 PyObject *resultobj = 0;
26764 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26765 bool result;
26766 void *argp1 = 0 ;
26767 int res1 = 0 ;
26768 PyObject *swig_obj[1] ;
26769
26770 if (!args) SWIG_fail;
26771 swig_obj[0] = args;
26772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26773 if (!SWIG_IsOK(res1)) {
26774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26775 }
26776 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 {
26784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26785 }
26786 return resultobj;
26787 fail:
26788 return NULL;
26789 }
26790
26791
26792 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26793 PyObject *resultobj = 0;
26794 wxIdleMode arg1 ;
26795 int val1 ;
26796 int ecode1 = 0 ;
26797 PyObject * obj0 = 0 ;
26798 char * kwnames[] = {
26799 (char *) "mode", NULL
26800 };
26801
26802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26803 ecode1 = SWIG_AsVal_int(obj0, &val1);
26804 if (!SWIG_IsOK(ecode1)) {
26805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26806 }
26807 arg1 = static_cast< wxIdleMode >(val1);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 wxIdleEvent::SetMode(arg1);
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 resultobj = SWIG_Py_Void();
26815 return resultobj;
26816 fail:
26817 return NULL;
26818 }
26819
26820
26821 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26822 PyObject *resultobj = 0;
26823 wxIdleMode result;
26824
26825 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 result = (wxIdleMode)wxIdleEvent::GetMode();
26829 wxPyEndAllowThreads(__tstate);
26830 if (PyErr_Occurred()) SWIG_fail;
26831 }
26832 resultobj = SWIG_From_int(static_cast< int >(result));
26833 return resultobj;
26834 fail:
26835 return NULL;
26836 }
26837
26838
26839 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26840 PyObject *resultobj = 0;
26841 wxWindow *arg1 = (wxWindow *) 0 ;
26842 bool result;
26843 void *argp1 = 0 ;
26844 int res1 = 0 ;
26845 PyObject * obj0 = 0 ;
26846 char * kwnames[] = {
26847 (char *) "win", NULL
26848 };
26849
26850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26852 if (!SWIG_IsOK(res1)) {
26853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26854 }
26855 arg1 = reinterpret_cast< wxWindow * >(argp1);
26856 {
26857 PyThreadState* __tstate = wxPyBeginAllowThreads();
26858 result = (bool)wxIdleEvent::CanSend(arg1);
26859 wxPyEndAllowThreads(__tstate);
26860 if (PyErr_Occurred()) SWIG_fail;
26861 }
26862 {
26863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26864 }
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *obj;
26873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26874 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26875 return SWIG_Py_Void();
26876 }
26877
26878 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26879 return SWIG_Python_InitShadowInstance(args);
26880 }
26881
26882 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26883 PyObject *resultobj = 0;
26884 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26885 int arg2 = (int) 0 ;
26886 wxClipboardTextEvent *result = 0 ;
26887 int val1 ;
26888 int ecode1 = 0 ;
26889 int val2 ;
26890 int ecode2 = 0 ;
26891 PyObject * obj0 = 0 ;
26892 PyObject * obj1 = 0 ;
26893 char * kwnames[] = {
26894 (char *) "type",(char *) "winid", NULL
26895 };
26896
26897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26898 if (obj0) {
26899 ecode1 = SWIG_AsVal_int(obj0, &val1);
26900 if (!SWIG_IsOK(ecode1)) {
26901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26902 }
26903 arg1 = static_cast< wxEventType >(val1);
26904 }
26905 if (obj1) {
26906 ecode2 = SWIG_AsVal_int(obj1, &val2);
26907 if (!SWIG_IsOK(ecode2)) {
26908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26909 }
26910 arg2 = static_cast< int >(val2);
26911 }
26912 {
26913 PyThreadState* __tstate = wxPyBeginAllowThreads();
26914 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26915 wxPyEndAllowThreads(__tstate);
26916 if (PyErr_Occurred()) SWIG_fail;
26917 }
26918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26919 return resultobj;
26920 fail:
26921 return NULL;
26922 }
26923
26924
26925 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26926 PyObject *obj;
26927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26928 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26929 return SWIG_Py_Void();
26930 }
26931
26932 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26933 return SWIG_Python_InitShadowInstance(args);
26934 }
26935
26936 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26937 PyObject *resultobj = 0;
26938 int arg1 = (int) 0 ;
26939 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26940 wxPyEvent *result = 0 ;
26941 int val1 ;
26942 int ecode1 = 0 ;
26943 int val2 ;
26944 int ecode2 = 0 ;
26945 PyObject * obj0 = 0 ;
26946 PyObject * obj1 = 0 ;
26947 char * kwnames[] = {
26948 (char *) "winid",(char *) "eventType", NULL
26949 };
26950
26951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26952 if (obj0) {
26953 ecode1 = SWIG_AsVal_int(obj0, &val1);
26954 if (!SWIG_IsOK(ecode1)) {
26955 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26956 }
26957 arg1 = static_cast< int >(val1);
26958 }
26959 if (obj1) {
26960 ecode2 = SWIG_AsVal_int(obj1, &val2);
26961 if (!SWIG_IsOK(ecode2)) {
26962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26963 }
26964 arg2 = static_cast< wxEventType >(val2);
26965 }
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26973 return resultobj;
26974 fail:
26975 return NULL;
26976 }
26977
26978
26979 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26980 PyObject *resultobj = 0;
26981 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26982 void *argp1 = 0 ;
26983 int res1 = 0 ;
26984 PyObject *swig_obj[1] ;
26985
26986 if (!args) SWIG_fail;
26987 swig_obj[0] = args;
26988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26989 if (!SWIG_IsOK(res1)) {
26990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26991 }
26992 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 delete arg1;
26996
26997 wxPyEndAllowThreads(__tstate);
26998 if (PyErr_Occurred()) SWIG_fail;
26999 }
27000 resultobj = SWIG_Py_Void();
27001 return resultobj;
27002 fail:
27003 return NULL;
27004 }
27005
27006
27007 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27008 PyObject *resultobj = 0;
27009 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27010 PyObject *arg2 = (PyObject *) 0 ;
27011 void *argp1 = 0 ;
27012 int res1 = 0 ;
27013 PyObject * obj0 = 0 ;
27014 PyObject * obj1 = 0 ;
27015 char * kwnames[] = {
27016 (char *) "self",(char *) "self", NULL
27017 };
27018
27019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27021 if (!SWIG_IsOK(res1)) {
27022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27023 }
27024 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27025 arg2 = obj1;
27026 {
27027 PyThreadState* __tstate = wxPyBeginAllowThreads();
27028 (arg1)->SetSelf(arg2);
27029 wxPyEndAllowThreads(__tstate);
27030 if (PyErr_Occurred()) SWIG_fail;
27031 }
27032 resultobj = SWIG_Py_Void();
27033 return resultobj;
27034 fail:
27035 return NULL;
27036 }
27037
27038
27039 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27040 PyObject *resultobj = 0;
27041 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27042 PyObject *result = 0 ;
27043 void *argp1 = 0 ;
27044 int res1 = 0 ;
27045 PyObject *swig_obj[1] ;
27046
27047 if (!args) SWIG_fail;
27048 swig_obj[0] = args;
27049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27050 if (!SWIG_IsOK(res1)) {
27051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27052 }
27053 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27054 {
27055 PyThreadState* __tstate = wxPyBeginAllowThreads();
27056 result = (PyObject *)(arg1)->GetSelf();
27057 wxPyEndAllowThreads(__tstate);
27058 if (PyErr_Occurred()) SWIG_fail;
27059 }
27060 resultobj = result;
27061 return resultobj;
27062 fail:
27063 return NULL;
27064 }
27065
27066
27067 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27068 PyObject *obj;
27069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27070 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27071 return SWIG_Py_Void();
27072 }
27073
27074 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27075 return SWIG_Python_InitShadowInstance(args);
27076 }
27077
27078 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27079 PyObject *resultobj = 0;
27080 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27081 int arg2 = (int) 0 ;
27082 wxPyCommandEvent *result = 0 ;
27083 int val1 ;
27084 int ecode1 = 0 ;
27085 int val2 ;
27086 int ecode2 = 0 ;
27087 PyObject * obj0 = 0 ;
27088 PyObject * obj1 = 0 ;
27089 char * kwnames[] = {
27090 (char *) "eventType",(char *) "id", NULL
27091 };
27092
27093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27094 if (obj0) {
27095 ecode1 = SWIG_AsVal_int(obj0, &val1);
27096 if (!SWIG_IsOK(ecode1)) {
27097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27098 }
27099 arg1 = static_cast< wxEventType >(val1);
27100 }
27101 if (obj1) {
27102 ecode2 = SWIG_AsVal_int(obj1, &val2);
27103 if (!SWIG_IsOK(ecode2)) {
27104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27105 }
27106 arg2 = static_cast< int >(val2);
27107 }
27108 {
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27111 wxPyEndAllowThreads(__tstate);
27112 if (PyErr_Occurred()) SWIG_fail;
27113 }
27114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27115 return resultobj;
27116 fail:
27117 return NULL;
27118 }
27119
27120
27121 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27122 PyObject *resultobj = 0;
27123 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27124 void *argp1 = 0 ;
27125 int res1 = 0 ;
27126 PyObject *swig_obj[1] ;
27127
27128 if (!args) SWIG_fail;
27129 swig_obj[0] = args;
27130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27133 }
27134 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 delete arg1;
27138
27139 wxPyEndAllowThreads(__tstate);
27140 if (PyErr_Occurred()) SWIG_fail;
27141 }
27142 resultobj = SWIG_Py_Void();
27143 return resultobj;
27144 fail:
27145 return NULL;
27146 }
27147
27148
27149 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27150 PyObject *resultobj = 0;
27151 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27152 PyObject *arg2 = (PyObject *) 0 ;
27153 void *argp1 = 0 ;
27154 int res1 = 0 ;
27155 PyObject * obj0 = 0 ;
27156 PyObject * obj1 = 0 ;
27157 char * kwnames[] = {
27158 (char *) "self",(char *) "self", NULL
27159 };
27160
27161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27163 if (!SWIG_IsOK(res1)) {
27164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27165 }
27166 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27167 arg2 = obj1;
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 (arg1)->SetSelf(arg2);
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 resultobj = SWIG_Py_Void();
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27182 PyObject *resultobj = 0;
27183 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27184 PyObject *result = 0 ;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 PyObject *swig_obj[1] ;
27188
27189 if (!args) SWIG_fail;
27190 swig_obj[0] = args;
27191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27192 if (!SWIG_IsOK(res1)) {
27193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27194 }
27195 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (PyObject *)(arg1)->GetSelf();
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 resultobj = result;
27203 return resultobj;
27204 fail:
27205 return NULL;
27206 }
27207
27208
27209 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27210 PyObject *obj;
27211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27212 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27213 return SWIG_Py_Void();
27214 }
27215
27216 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27217 return SWIG_Python_InitShadowInstance(args);
27218 }
27219
27220 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27221 PyObject *resultobj = 0;
27222 wxWindow *arg1 = (wxWindow *) 0 ;
27223 wxDateTime *arg2 = 0 ;
27224 wxEventType arg3 ;
27225 wxDateEvent *result = 0 ;
27226 void *argp1 = 0 ;
27227 int res1 = 0 ;
27228 void *argp2 = 0 ;
27229 int res2 = 0 ;
27230 int val3 ;
27231 int ecode3 = 0 ;
27232 PyObject * obj0 = 0 ;
27233 PyObject * obj1 = 0 ;
27234 PyObject * obj2 = 0 ;
27235 char * kwnames[] = {
27236 (char *) "win",(char *) "dt",(char *) "type", NULL
27237 };
27238
27239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27241 if (!SWIG_IsOK(res1)) {
27242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27243 }
27244 arg1 = reinterpret_cast< wxWindow * >(argp1);
27245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27246 if (!SWIG_IsOK(res2)) {
27247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27248 }
27249 if (!argp2) {
27250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27251 }
27252 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27253 ecode3 = SWIG_AsVal_int(obj2, &val3);
27254 if (!SWIG_IsOK(ecode3)) {
27255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27256 }
27257 arg3 = static_cast< wxEventType >(val3);
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27261 wxPyEndAllowThreads(__tstate);
27262 if (PyErr_Occurred()) SWIG_fail;
27263 }
27264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27265 return resultobj;
27266 fail:
27267 return NULL;
27268 }
27269
27270
27271 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27272 PyObject *resultobj = 0;
27273 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27274 wxDateTime *result = 0 ;
27275 void *argp1 = 0 ;
27276 int res1 = 0 ;
27277 PyObject *swig_obj[1] ;
27278
27279 if (!args) SWIG_fail;
27280 swig_obj[0] = args;
27281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27282 if (!SWIG_IsOK(res1)) {
27283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27284 }
27285 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27286 {
27287 PyThreadState* __tstate = wxPyBeginAllowThreads();
27288 {
27289 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27290 result = (wxDateTime *) &_result_ref;
27291 }
27292 wxPyEndAllowThreads(__tstate);
27293 if (PyErr_Occurred()) SWIG_fail;
27294 }
27295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27296 return resultobj;
27297 fail:
27298 return NULL;
27299 }
27300
27301
27302 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27303 PyObject *resultobj = 0;
27304 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27305 wxDateTime *arg2 = 0 ;
27306 void *argp1 = 0 ;
27307 int res1 = 0 ;
27308 void *argp2 = 0 ;
27309 int res2 = 0 ;
27310 PyObject * obj0 = 0 ;
27311 PyObject * obj1 = 0 ;
27312 char * kwnames[] = {
27313 (char *) "self",(char *) "date", NULL
27314 };
27315
27316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27318 if (!SWIG_IsOK(res1)) {
27319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27320 }
27321 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27322 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27323 if (!SWIG_IsOK(res2)) {
27324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27325 }
27326 if (!argp2) {
27327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27328 }
27329 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27330 {
27331 PyThreadState* __tstate = wxPyBeginAllowThreads();
27332 (arg1)->SetDate((wxDateTime const &)*arg2);
27333 wxPyEndAllowThreads(__tstate);
27334 if (PyErr_Occurred()) SWIG_fail;
27335 }
27336 resultobj = SWIG_Py_Void();
27337 return resultobj;
27338 fail:
27339 return NULL;
27340 }
27341
27342
27343 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27344 PyObject *obj;
27345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27346 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27347 return SWIG_Py_Void();
27348 }
27349
27350 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27351 return SWIG_Python_InitShadowInstance(args);
27352 }
27353
27354 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27355 PyObject *resultobj = 0;
27356 wxPyApp *result = 0 ;
27357
27358 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27359 {
27360 PyThreadState* __tstate = wxPyBeginAllowThreads();
27361 result = (wxPyApp *)new_wxPyApp();
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27373 PyObject *resultobj = 0;
27374 wxPyApp *arg1 = (wxPyApp *) 0 ;
27375 void *argp1 = 0 ;
27376 int res1 = 0 ;
27377 PyObject *swig_obj[1] ;
27378
27379 if (!args) SWIG_fail;
27380 swig_obj[0] = args;
27381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27384 }
27385 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 delete arg1;
27389
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_Py_Void();
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27401 PyObject *resultobj = 0;
27402 wxPyApp *arg1 = (wxPyApp *) 0 ;
27403 PyObject *arg2 = (PyObject *) 0 ;
27404 PyObject *arg3 = (PyObject *) 0 ;
27405 bool arg4 ;
27406 void *argp1 = 0 ;
27407 int res1 = 0 ;
27408 bool val4 ;
27409 int ecode4 = 0 ;
27410 PyObject * obj0 = 0 ;
27411 PyObject * obj1 = 0 ;
27412 PyObject * obj2 = 0 ;
27413 PyObject * obj3 = 0 ;
27414 char * kwnames[] = {
27415 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27416 };
27417
27418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27420 if (!SWIG_IsOK(res1)) {
27421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27422 }
27423 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27424 arg2 = obj1;
27425 arg3 = obj2;
27426 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27427 if (!SWIG_IsOK(ecode4)) {
27428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27429 }
27430 arg4 = static_cast< bool >(val4);
27431 {
27432 PyThreadState* __tstate = wxPyBeginAllowThreads();
27433 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27434 wxPyEndAllowThreads(__tstate);
27435 if (PyErr_Occurred()) SWIG_fail;
27436 }
27437 resultobj = SWIG_Py_Void();
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27445 PyObject *resultobj = 0;
27446 wxPyApp *arg1 = (wxPyApp *) 0 ;
27447 wxString result;
27448 void *argp1 = 0 ;
27449 int res1 = 0 ;
27450 PyObject *swig_obj[1] ;
27451
27452 if (!args) SWIG_fail;
27453 swig_obj[0] = args;
27454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27455 if (!SWIG_IsOK(res1)) {
27456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27457 }
27458 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 result = ((wxPyApp const *)arg1)->GetAppName();
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 #if wxUSE_UNICODE
27467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27468 #else
27469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27470 #endif
27471 }
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27479 PyObject *resultobj = 0;
27480 wxPyApp *arg1 = (wxPyApp *) 0 ;
27481 wxString *arg2 = 0 ;
27482 void *argp1 = 0 ;
27483 int res1 = 0 ;
27484 bool temp2 = false ;
27485 PyObject * obj0 = 0 ;
27486 PyObject * obj1 = 0 ;
27487 char * kwnames[] = {
27488 (char *) "self",(char *) "name", NULL
27489 };
27490
27491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27493 if (!SWIG_IsOK(res1)) {
27494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27495 }
27496 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27497 {
27498 arg2 = wxString_in_helper(obj1);
27499 if (arg2 == NULL) SWIG_fail;
27500 temp2 = true;
27501 }
27502 {
27503 PyThreadState* __tstate = wxPyBeginAllowThreads();
27504 (arg1)->SetAppName((wxString const &)*arg2);
27505 wxPyEndAllowThreads(__tstate);
27506 if (PyErr_Occurred()) SWIG_fail;
27507 }
27508 resultobj = SWIG_Py_Void();
27509 {
27510 if (temp2)
27511 delete arg2;
27512 }
27513 return resultobj;
27514 fail:
27515 {
27516 if (temp2)
27517 delete arg2;
27518 }
27519 return NULL;
27520 }
27521
27522
27523 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27524 PyObject *resultobj = 0;
27525 wxPyApp *arg1 = (wxPyApp *) 0 ;
27526 wxString result;
27527 void *argp1 = 0 ;
27528 int res1 = 0 ;
27529 PyObject *swig_obj[1] ;
27530
27531 if (!args) SWIG_fail;
27532 swig_obj[0] = args;
27533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27534 if (!SWIG_IsOK(res1)) {
27535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27536 }
27537 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 result = ((wxPyApp const *)arg1)->GetClassName();
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 {
27545 #if wxUSE_UNICODE
27546 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27547 #else
27548 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27549 #endif
27550 }
27551 return resultobj;
27552 fail:
27553 return NULL;
27554 }
27555
27556
27557 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27558 PyObject *resultobj = 0;
27559 wxPyApp *arg1 = (wxPyApp *) 0 ;
27560 wxString *arg2 = 0 ;
27561 void *argp1 = 0 ;
27562 int res1 = 0 ;
27563 bool temp2 = false ;
27564 PyObject * obj0 = 0 ;
27565 PyObject * obj1 = 0 ;
27566 char * kwnames[] = {
27567 (char *) "self",(char *) "name", NULL
27568 };
27569
27570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27572 if (!SWIG_IsOK(res1)) {
27573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27574 }
27575 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27576 {
27577 arg2 = wxString_in_helper(obj1);
27578 if (arg2 == NULL) SWIG_fail;
27579 temp2 = true;
27580 }
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 (arg1)->SetClassName((wxString const &)*arg2);
27584 wxPyEndAllowThreads(__tstate);
27585 if (PyErr_Occurred()) SWIG_fail;
27586 }
27587 resultobj = SWIG_Py_Void();
27588 {
27589 if (temp2)
27590 delete arg2;
27591 }
27592 return resultobj;
27593 fail:
27594 {
27595 if (temp2)
27596 delete arg2;
27597 }
27598 return NULL;
27599 }
27600
27601
27602 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27603 PyObject *resultobj = 0;
27604 wxPyApp *arg1 = (wxPyApp *) 0 ;
27605 wxString *result = 0 ;
27606 void *argp1 = 0 ;
27607 int res1 = 0 ;
27608 PyObject *swig_obj[1] ;
27609
27610 if (!args) SWIG_fail;
27611 swig_obj[0] = args;
27612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27613 if (!SWIG_IsOK(res1)) {
27614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27615 }
27616 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 {
27620 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27621 result = (wxString *) &_result_ref;
27622 }
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 {
27627 #if wxUSE_UNICODE
27628 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27629 #else
27630 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27631 #endif
27632 }
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj = 0;
27641 wxPyApp *arg1 = (wxPyApp *) 0 ;
27642 wxString *arg2 = 0 ;
27643 void *argp1 = 0 ;
27644 int res1 = 0 ;
27645 bool temp2 = false ;
27646 PyObject * obj0 = 0 ;
27647 PyObject * obj1 = 0 ;
27648 char * kwnames[] = {
27649 (char *) "self",(char *) "name", NULL
27650 };
27651
27652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27654 if (!SWIG_IsOK(res1)) {
27655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27656 }
27657 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27658 {
27659 arg2 = wxString_in_helper(obj1);
27660 if (arg2 == NULL) SWIG_fail;
27661 temp2 = true;
27662 }
27663 {
27664 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 (arg1)->SetVendorName((wxString const &)*arg2);
27666 wxPyEndAllowThreads(__tstate);
27667 if (PyErr_Occurred()) SWIG_fail;
27668 }
27669 resultobj = SWIG_Py_Void();
27670 {
27671 if (temp2)
27672 delete arg2;
27673 }
27674 return resultobj;
27675 fail:
27676 {
27677 if (temp2)
27678 delete arg2;
27679 }
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27685 PyObject *resultobj = 0;
27686 wxPyApp *arg1 = (wxPyApp *) 0 ;
27687 wxAppTraits *result = 0 ;
27688 void *argp1 = 0 ;
27689 int res1 = 0 ;
27690 PyObject *swig_obj[1] ;
27691
27692 if (!args) SWIG_fail;
27693 swig_obj[0] = args;
27694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27695 if (!SWIG_IsOK(res1)) {
27696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27697 }
27698 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27699 {
27700 PyThreadState* __tstate = wxPyBeginAllowThreads();
27701 result = (wxAppTraits *)(arg1)->GetTraits();
27702 wxPyEndAllowThreads(__tstate);
27703 if (PyErr_Occurred()) SWIG_fail;
27704 }
27705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27706 return resultobj;
27707 fail:
27708 return NULL;
27709 }
27710
27711
27712 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27713 PyObject *resultobj = 0;
27714 wxPyApp *arg1 = (wxPyApp *) 0 ;
27715 void *argp1 = 0 ;
27716 int res1 = 0 ;
27717 PyObject *swig_obj[1] ;
27718
27719 if (!args) SWIG_fail;
27720 swig_obj[0] = args;
27721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27722 if (!SWIG_IsOK(res1)) {
27723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27724 }
27725 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27726 {
27727 PyThreadState* __tstate = wxPyBeginAllowThreads();
27728 (arg1)->ProcessPendingEvents();
27729 wxPyEndAllowThreads(__tstate);
27730 if (PyErr_Occurred()) SWIG_fail;
27731 }
27732 resultobj = SWIG_Py_Void();
27733 return resultobj;
27734 fail:
27735 return NULL;
27736 }
27737
27738
27739 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27740 PyObject *resultobj = 0;
27741 wxPyApp *arg1 = (wxPyApp *) 0 ;
27742 bool arg2 = (bool) false ;
27743 bool result;
27744 void *argp1 = 0 ;
27745 int res1 = 0 ;
27746 bool val2 ;
27747 int ecode2 = 0 ;
27748 PyObject * obj0 = 0 ;
27749 PyObject * obj1 = 0 ;
27750 char * kwnames[] = {
27751 (char *) "self",(char *) "onlyIfNeeded", NULL
27752 };
27753
27754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27756 if (!SWIG_IsOK(res1)) {
27757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27758 }
27759 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27760 if (obj1) {
27761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27762 if (!SWIG_IsOK(ecode2)) {
27763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27764 }
27765 arg2 = static_cast< bool >(val2);
27766 }
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = (bool)(arg1)->Yield(arg2);
27770 wxPyEndAllowThreads(__tstate);
27771 if (PyErr_Occurred()) SWIG_fail;
27772 }
27773 {
27774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27775 }
27776 return resultobj;
27777 fail:
27778 return NULL;
27779 }
27780
27781
27782 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27783 PyObject *resultobj = 0;
27784 wxPyApp *arg1 = (wxPyApp *) 0 ;
27785 void *argp1 = 0 ;
27786 int res1 = 0 ;
27787 PyObject *swig_obj[1] ;
27788
27789 if (!args) SWIG_fail;
27790 swig_obj[0] = args;
27791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27792 if (!SWIG_IsOK(res1)) {
27793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27794 }
27795 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27796 {
27797 PyThreadState* __tstate = wxPyBeginAllowThreads();
27798 (arg1)->WakeUpIdle();
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 resultobj = SWIG_Py_Void();
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 PyObject *resultobj = 0;
27811 bool result;
27812
27813 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = (bool)wxPyApp::IsMainLoopRunning();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 {
27821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27822 }
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27830 PyObject *resultobj = 0;
27831 wxPyApp *arg1 = (wxPyApp *) 0 ;
27832 int result;
27833 void *argp1 = 0 ;
27834 int res1 = 0 ;
27835 PyObject *swig_obj[1] ;
27836
27837 if (!args) SWIG_fail;
27838 swig_obj[0] = args;
27839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27840 if (!SWIG_IsOK(res1)) {
27841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27842 }
27843 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27844 {
27845 PyThreadState* __tstate = wxPyBeginAllowThreads();
27846 result = (int)(arg1)->MainLoop();
27847 wxPyEndAllowThreads(__tstate);
27848 if (PyErr_Occurred()) SWIG_fail;
27849 }
27850 resultobj = SWIG_From_int(static_cast< int >(result));
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27858 PyObject *resultobj = 0;
27859 wxPyApp *arg1 = (wxPyApp *) 0 ;
27860 void *argp1 = 0 ;
27861 int res1 = 0 ;
27862 PyObject *swig_obj[1] ;
27863
27864 if (!args) SWIG_fail;
27865 swig_obj[0] = args;
27866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27867 if (!SWIG_IsOK(res1)) {
27868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27869 }
27870 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27871 {
27872 PyThreadState* __tstate = wxPyBeginAllowThreads();
27873 (arg1)->Exit();
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 resultobj = SWIG_Py_Void();
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27885 PyObject *resultobj = 0;
27886 wxPyApp *arg1 = (wxPyApp *) 0 ;
27887 wxLayoutDirection result;
27888 void *argp1 = 0 ;
27889 int res1 = 0 ;
27890 PyObject *swig_obj[1] ;
27891
27892 if (!args) SWIG_fail;
27893 swig_obj[0] = args;
27894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27895 if (!SWIG_IsOK(res1)) {
27896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27897 }
27898 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27899 {
27900 PyThreadState* __tstate = wxPyBeginAllowThreads();
27901 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 resultobj = SWIG_From_int(static_cast< int >(result));
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27913 PyObject *resultobj = 0;
27914 wxPyApp *arg1 = (wxPyApp *) 0 ;
27915 void *argp1 = 0 ;
27916 int res1 = 0 ;
27917 PyObject *swig_obj[1] ;
27918
27919 if (!args) SWIG_fail;
27920 swig_obj[0] = args;
27921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27924 }
27925 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 (arg1)->ExitMainLoop();
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 resultobj = SWIG_Py_Void();
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27940 PyObject *resultobj = 0;
27941 wxPyApp *arg1 = (wxPyApp *) 0 ;
27942 bool result;
27943 void *argp1 = 0 ;
27944 int res1 = 0 ;
27945 PyObject *swig_obj[1] ;
27946
27947 if (!args) SWIG_fail;
27948 swig_obj[0] = args;
27949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27950 if (!SWIG_IsOK(res1)) {
27951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27952 }
27953 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27954 {
27955 PyThreadState* __tstate = wxPyBeginAllowThreads();
27956 result = (bool)(arg1)->Pending();
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 {
27961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27962 }
27963 return resultobj;
27964 fail:
27965 return NULL;
27966 }
27967
27968
27969 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27970 PyObject *resultobj = 0;
27971 wxPyApp *arg1 = (wxPyApp *) 0 ;
27972 bool result;
27973 void *argp1 = 0 ;
27974 int res1 = 0 ;
27975 PyObject *swig_obj[1] ;
27976
27977 if (!args) SWIG_fail;
27978 swig_obj[0] = args;
27979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27980 if (!SWIG_IsOK(res1)) {
27981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27982 }
27983 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 result = (bool)(arg1)->Dispatch();
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 {
27991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27992 }
27993 return resultobj;
27994 fail:
27995 return NULL;
27996 }
27997
27998
27999 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28000 PyObject *resultobj = 0;
28001 wxPyApp *arg1 = (wxPyApp *) 0 ;
28002 bool result;
28003 void *argp1 = 0 ;
28004 int res1 = 0 ;
28005 PyObject *swig_obj[1] ;
28006
28007 if (!args) SWIG_fail;
28008 swig_obj[0] = args;
28009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28010 if (!SWIG_IsOK(res1)) {
28011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28012 }
28013 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28014 {
28015 PyThreadState* __tstate = wxPyBeginAllowThreads();
28016 result = (bool)(arg1)->ProcessIdle();
28017 wxPyEndAllowThreads(__tstate);
28018 if (PyErr_Occurred()) SWIG_fail;
28019 }
28020 {
28021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28022 }
28023 return resultobj;
28024 fail:
28025 return NULL;
28026 }
28027
28028
28029 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28030 PyObject *resultobj = 0;
28031 wxPyApp *arg1 = (wxPyApp *) 0 ;
28032 wxWindow *arg2 = (wxWindow *) 0 ;
28033 wxIdleEvent *arg3 = 0 ;
28034 bool result;
28035 void *argp1 = 0 ;
28036 int res1 = 0 ;
28037 void *argp2 = 0 ;
28038 int res2 = 0 ;
28039 void *argp3 = 0 ;
28040 int res3 = 0 ;
28041 PyObject * obj0 = 0 ;
28042 PyObject * obj1 = 0 ;
28043 PyObject * obj2 = 0 ;
28044 char * kwnames[] = {
28045 (char *) "self",(char *) "win",(char *) "event", NULL
28046 };
28047
28048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28050 if (!SWIG_IsOK(res1)) {
28051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28052 }
28053 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28055 if (!SWIG_IsOK(res2)) {
28056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28057 }
28058 arg2 = reinterpret_cast< wxWindow * >(argp2);
28059 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28060 if (!SWIG_IsOK(res3)) {
28061 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28062 }
28063 if (!argp3) {
28064 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28065 }
28066 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 {
28074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28075 }
28076 return resultobj;
28077 fail:
28078 return NULL;
28079 }
28080
28081
28082 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28083 PyObject *resultobj = 0;
28084 wxPyApp *arg1 = (wxPyApp *) 0 ;
28085 bool result;
28086 void *argp1 = 0 ;
28087 int res1 = 0 ;
28088 PyObject *swig_obj[1] ;
28089
28090 if (!args) SWIG_fail;
28091 swig_obj[0] = args;
28092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28093 if (!SWIG_IsOK(res1)) {
28094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28095 }
28096 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 result = (bool)((wxPyApp const *)arg1)->IsActive();
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 {
28104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28105 }
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj = 0;
28114 wxPyApp *arg1 = (wxPyApp *) 0 ;
28115 wxWindow *arg2 = (wxWindow *) 0 ;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 void *argp2 = 0 ;
28119 int res2 = 0 ;
28120 PyObject * obj0 = 0 ;
28121 PyObject * obj1 = 0 ;
28122 char * kwnames[] = {
28123 (char *) "self",(char *) "win", NULL
28124 };
28125
28126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28128 if (!SWIG_IsOK(res1)) {
28129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28130 }
28131 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28133 if (!SWIG_IsOK(res2)) {
28134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28135 }
28136 arg2 = reinterpret_cast< wxWindow * >(argp2);
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 (arg1)->SetTopWindow(arg2);
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_Py_Void();
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28151 PyObject *resultobj = 0;
28152 wxPyApp *arg1 = (wxPyApp *) 0 ;
28153 wxWindow *result = 0 ;
28154 void *argp1 = 0 ;
28155 int res1 = 0 ;
28156 PyObject *swig_obj[1] ;
28157
28158 if (!args) SWIG_fail;
28159 swig_obj[0] = args;
28160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28161 if (!SWIG_IsOK(res1)) {
28162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28163 }
28164 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28165 {
28166 PyThreadState* __tstate = wxPyBeginAllowThreads();
28167 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 {
28172 resultobj = wxPyMake_wxObject(result, (bool)0);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj = 0;
28182 wxPyApp *arg1 = (wxPyApp *) 0 ;
28183 bool arg2 ;
28184 void *argp1 = 0 ;
28185 int res1 = 0 ;
28186 bool val2 ;
28187 int ecode2 = 0 ;
28188 PyObject * obj0 = 0 ;
28189 PyObject * obj1 = 0 ;
28190 char * kwnames[] = {
28191 (char *) "self",(char *) "flag", NULL
28192 };
28193
28194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28196 if (!SWIG_IsOK(res1)) {
28197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28198 }
28199 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28200 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28201 if (!SWIG_IsOK(ecode2)) {
28202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28203 }
28204 arg2 = static_cast< bool >(val2);
28205 {
28206 PyThreadState* __tstate = wxPyBeginAllowThreads();
28207 (arg1)->SetExitOnFrameDelete(arg2);
28208 wxPyEndAllowThreads(__tstate);
28209 if (PyErr_Occurred()) SWIG_fail;
28210 }
28211 resultobj = SWIG_Py_Void();
28212 return resultobj;
28213 fail:
28214 return NULL;
28215 }
28216
28217
28218 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28219 PyObject *resultobj = 0;
28220 wxPyApp *arg1 = (wxPyApp *) 0 ;
28221 bool result;
28222 void *argp1 = 0 ;
28223 int res1 = 0 ;
28224 PyObject *swig_obj[1] ;
28225
28226 if (!args) SWIG_fail;
28227 swig_obj[0] = args;
28228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28229 if (!SWIG_IsOK(res1)) {
28230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28231 }
28232 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28233 {
28234 PyThreadState* __tstate = wxPyBeginAllowThreads();
28235 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28236 wxPyEndAllowThreads(__tstate);
28237 if (PyErr_Occurred()) SWIG_fail;
28238 }
28239 {
28240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28241 }
28242 return resultobj;
28243 fail:
28244 return NULL;
28245 }
28246
28247
28248 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28249 PyObject *resultobj = 0;
28250 wxPyApp *arg1 = (wxPyApp *) 0 ;
28251 bool arg2 ;
28252 void *argp1 = 0 ;
28253 int res1 = 0 ;
28254 bool val2 ;
28255 int ecode2 = 0 ;
28256 PyObject * obj0 = 0 ;
28257 PyObject * obj1 = 0 ;
28258 char * kwnames[] = {
28259 (char *) "self",(char *) "flag", NULL
28260 };
28261
28262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28264 if (!SWIG_IsOK(res1)) {
28265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28266 }
28267 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28268 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28269 if (!SWIG_IsOK(ecode2)) {
28270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28271 }
28272 arg2 = static_cast< bool >(val2);
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 (arg1)->SetUseBestVisual(arg2);
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 resultobj = SWIG_Py_Void();
28280 return resultobj;
28281 fail:
28282 return NULL;
28283 }
28284
28285
28286 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28287 PyObject *resultobj = 0;
28288 wxPyApp *arg1 = (wxPyApp *) 0 ;
28289 bool result;
28290 void *argp1 = 0 ;
28291 int res1 = 0 ;
28292 PyObject *swig_obj[1] ;
28293
28294 if (!args) SWIG_fail;
28295 swig_obj[0] = args;
28296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28297 if (!SWIG_IsOK(res1)) {
28298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28299 }
28300 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28304 wxPyEndAllowThreads(__tstate);
28305 if (PyErr_Occurred()) SWIG_fail;
28306 }
28307 {
28308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28309 }
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28317 PyObject *resultobj = 0;
28318 wxPyApp *arg1 = (wxPyApp *) 0 ;
28319 int arg2 ;
28320 void *argp1 = 0 ;
28321 int res1 = 0 ;
28322 int val2 ;
28323 int ecode2 = 0 ;
28324 PyObject * obj0 = 0 ;
28325 PyObject * obj1 = 0 ;
28326 char * kwnames[] = {
28327 (char *) "self",(char *) "mode", NULL
28328 };
28329
28330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28332 if (!SWIG_IsOK(res1)) {
28333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28334 }
28335 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28336 ecode2 = SWIG_AsVal_int(obj1, &val2);
28337 if (!SWIG_IsOK(ecode2)) {
28338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28339 }
28340 arg2 = static_cast< int >(val2);
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 (arg1)->SetPrintMode(arg2);
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 resultobj = SWIG_Py_Void();
28348 return resultobj;
28349 fail:
28350 return NULL;
28351 }
28352
28353
28354 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28355 PyObject *resultobj = 0;
28356 wxPyApp *arg1 = (wxPyApp *) 0 ;
28357 int result;
28358 void *argp1 = 0 ;
28359 int res1 = 0 ;
28360 PyObject *swig_obj[1] ;
28361
28362 if (!args) SWIG_fail;
28363 swig_obj[0] = args;
28364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28365 if (!SWIG_IsOK(res1)) {
28366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28367 }
28368 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28372 wxPyEndAllowThreads(__tstate);
28373 if (PyErr_Occurred()) SWIG_fail;
28374 }
28375 resultobj = SWIG_From_int(static_cast< int >(result));
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28383 PyObject *resultobj = 0;
28384 wxPyApp *arg1 = (wxPyApp *) 0 ;
28385 int arg2 ;
28386 void *argp1 = 0 ;
28387 int res1 = 0 ;
28388 int val2 ;
28389 int ecode2 = 0 ;
28390 PyObject * obj0 = 0 ;
28391 PyObject * obj1 = 0 ;
28392 char * kwnames[] = {
28393 (char *) "self",(char *) "mode", NULL
28394 };
28395
28396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28398 if (!SWIG_IsOK(res1)) {
28399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28400 }
28401 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28402 ecode2 = SWIG_AsVal_int(obj1, &val2);
28403 if (!SWIG_IsOK(ecode2)) {
28404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28405 }
28406 arg2 = static_cast< int >(val2);
28407 {
28408 PyThreadState* __tstate = wxPyBeginAllowThreads();
28409 (arg1)->SetAssertMode(arg2);
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_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28421 PyObject *resultobj = 0;
28422 wxPyApp *arg1 = (wxPyApp *) 0 ;
28423 int result;
28424 void *argp1 = 0 ;
28425 int res1 = 0 ;
28426 PyObject *swig_obj[1] ;
28427
28428 if (!args) SWIG_fail;
28429 swig_obj[0] = args;
28430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28431 if (!SWIG_IsOK(res1)) {
28432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28433 }
28434 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 result = (int)(arg1)->GetAssertMode();
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 resultobj = SWIG_From_int(static_cast< int >(result));
28442 return resultobj;
28443 fail:
28444 return NULL;
28445 }
28446
28447
28448 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28449 PyObject *resultobj = 0;
28450 bool result;
28451
28452 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28469 PyObject *resultobj = 0;
28470 long result;
28471
28472 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 result = (long)wxPyApp::GetMacAboutMenuItemId();
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 resultobj = SWIG_From_long(static_cast< long >(result));
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28487 PyObject *resultobj = 0;
28488 long result;
28489
28490 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 resultobj = SWIG_From_long(static_cast< long >(result));
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *resultobj = 0;
28506 long result;
28507
28508 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (long)wxPyApp::GetMacExitMenuItemId();
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 resultobj = SWIG_From_long(static_cast< long >(result));
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28523 PyObject *resultobj = 0;
28524 wxString result;
28525
28526 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 result = wxPyApp::GetMacHelpMenuTitleName();
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 {
28534 #if wxUSE_UNICODE
28535 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28536 #else
28537 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28538 #endif
28539 }
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj = 0;
28548 bool arg1 ;
28549 bool val1 ;
28550 int ecode1 = 0 ;
28551 PyObject * obj0 = 0 ;
28552 char * kwnames[] = {
28553 (char *) "val", NULL
28554 };
28555
28556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28557 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28558 if (!SWIG_IsOK(ecode1)) {
28559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28560 }
28561 arg1 = static_cast< bool >(val1);
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 resultobj = SWIG_Py_Void();
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28576 PyObject *resultobj = 0;
28577 long arg1 ;
28578 long val1 ;
28579 int ecode1 = 0 ;
28580 PyObject * obj0 = 0 ;
28581 char * kwnames[] = {
28582 (char *) "val", NULL
28583 };
28584
28585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28586 ecode1 = SWIG_AsVal_long(obj0, &val1);
28587 if (!SWIG_IsOK(ecode1)) {
28588 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28589 }
28590 arg1 = static_cast< long >(val1);
28591 {
28592 PyThreadState* __tstate = wxPyBeginAllowThreads();
28593 wxPyApp::SetMacAboutMenuItemId(arg1);
28594 wxPyEndAllowThreads(__tstate);
28595 if (PyErr_Occurred()) SWIG_fail;
28596 }
28597 resultobj = SWIG_Py_Void();
28598 return resultobj;
28599 fail:
28600 return NULL;
28601 }
28602
28603
28604 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28605 PyObject *resultobj = 0;
28606 long arg1 ;
28607 long val1 ;
28608 int ecode1 = 0 ;
28609 PyObject * obj0 = 0 ;
28610 char * kwnames[] = {
28611 (char *) "val", NULL
28612 };
28613
28614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28615 ecode1 = SWIG_AsVal_long(obj0, &val1);
28616 if (!SWIG_IsOK(ecode1)) {
28617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28618 }
28619 arg1 = static_cast< long >(val1);
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 resultobj = SWIG_Py_Void();
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj = 0;
28635 long arg1 ;
28636 long val1 ;
28637 int ecode1 = 0 ;
28638 PyObject * obj0 = 0 ;
28639 char * kwnames[] = {
28640 (char *) "val", NULL
28641 };
28642
28643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28644 ecode1 = SWIG_AsVal_long(obj0, &val1);
28645 if (!SWIG_IsOK(ecode1)) {
28646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28647 }
28648 arg1 = static_cast< long >(val1);
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 wxPyApp::SetMacExitMenuItemId(arg1);
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_Py_Void();
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 wxString *arg1 = 0 ;
28665 bool temp1 = false ;
28666 PyObject * obj0 = 0 ;
28667 char * kwnames[] = {
28668 (char *) "val", NULL
28669 };
28670
28671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28672 {
28673 arg1 = wxString_in_helper(obj0);
28674 if (arg1 == NULL) SWIG_fail;
28675 temp1 = true;
28676 }
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28680 wxPyEndAllowThreads(__tstate);
28681 if (PyErr_Occurred()) SWIG_fail;
28682 }
28683 resultobj = SWIG_Py_Void();
28684 {
28685 if (temp1)
28686 delete arg1;
28687 }
28688 return resultobj;
28689 fail:
28690 {
28691 if (temp1)
28692 delete arg1;
28693 }
28694 return NULL;
28695 }
28696
28697
28698 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28699 PyObject *resultobj = 0;
28700 wxPyApp *arg1 = (wxPyApp *) 0 ;
28701 void *argp1 = 0 ;
28702 int res1 = 0 ;
28703 PyObject *swig_obj[1] ;
28704
28705 if (!args) SWIG_fail;
28706 swig_obj[0] = args;
28707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28708 if (!SWIG_IsOK(res1)) {
28709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28710 }
28711 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28712 {
28713 PyThreadState* __tstate = wxPyBeginAllowThreads();
28714 (arg1)->_BootstrapApp();
28715 wxPyEndAllowThreads(__tstate);
28716 if (PyErr_Occurred()) SWIG_fail;
28717 }
28718 resultobj = SWIG_Py_Void();
28719 return resultobj;
28720 fail:
28721 return NULL;
28722 }
28723
28724
28725 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28726 PyObject *resultobj = 0;
28727 int result;
28728
28729 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28730 {
28731 PyThreadState* __tstate = wxPyBeginAllowThreads();
28732 result = (int)wxPyApp::GetComCtl32Version();
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 resultobj = SWIG_From_int(static_cast< int >(result));
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28744 PyObject *resultobj = 0;
28745 bool result;
28746
28747 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28748 {
28749 PyThreadState* __tstate = wxPyBeginAllowThreads();
28750 result = (bool)wxPyApp_IsDisplayAvailable();
28751 wxPyEndAllowThreads(__tstate);
28752 if (PyErr_Occurred()) SWIG_fail;
28753 }
28754 {
28755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28756 }
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28764 PyObject *obj;
28765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28767 return SWIG_Py_Void();
28768 }
28769
28770 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28771 return SWIG_Python_InitShadowInstance(args);
28772 }
28773
28774 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28775 PyObject *resultobj = 0;
28776
28777 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 wxExit();
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 resultobj = SWIG_Py_Void();
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28792 PyObject *resultobj = 0;
28793 bool result;
28794
28795 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 result = (bool)wxYield();
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 {
28803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28804 }
28805 return resultobj;
28806 fail:
28807 return NULL;
28808 }
28809
28810
28811 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28812 PyObject *resultobj = 0;
28813 bool result;
28814
28815 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28816 {
28817 PyThreadState* __tstate = wxPyBeginAllowThreads();
28818 result = (bool)wxYieldIfNeeded();
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 {
28823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28824 }
28825 return resultobj;
28826 fail:
28827 return NULL;
28828 }
28829
28830
28831 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28832 PyObject *resultobj = 0;
28833 wxWindow *arg1 = (wxWindow *) NULL ;
28834 bool arg2 = (bool) false ;
28835 bool result;
28836 void *argp1 = 0 ;
28837 int res1 = 0 ;
28838 bool val2 ;
28839 int ecode2 = 0 ;
28840 PyObject * obj0 = 0 ;
28841 PyObject * obj1 = 0 ;
28842 char * kwnames[] = {
28843 (char *) "win",(char *) "onlyIfNeeded", NULL
28844 };
28845
28846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28847 if (obj0) {
28848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28849 if (!SWIG_IsOK(res1)) {
28850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28851 }
28852 arg1 = reinterpret_cast< wxWindow * >(argp1);
28853 }
28854 if (obj1) {
28855 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28856 if (!SWIG_IsOK(ecode2)) {
28857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28858 }
28859 arg2 = static_cast< bool >(val2);
28860 }
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 result = (bool)wxSafeYield(arg1,arg2);
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 {
28868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28869 }
28870 return resultobj;
28871 fail:
28872 return NULL;
28873 }
28874
28875
28876 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28877 PyObject *resultobj = 0;
28878
28879 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 wxWakeUpIdle();
28883 wxPyEndAllowThreads(__tstate);
28884 if (PyErr_Occurred()) SWIG_fail;
28885 }
28886 resultobj = SWIG_Py_Void();
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28894 PyObject *resultobj = 0;
28895 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28896 wxEvent *arg2 = 0 ;
28897 void *argp1 = 0 ;
28898 int res1 = 0 ;
28899 void *argp2 = 0 ;
28900 int res2 = 0 ;
28901 PyObject * obj0 = 0 ;
28902 PyObject * obj1 = 0 ;
28903 char * kwnames[] = {
28904 (char *) "dest",(char *) "event", NULL
28905 };
28906
28907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28909 if (!SWIG_IsOK(res1)) {
28910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28911 }
28912 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28914 if (!SWIG_IsOK(res2)) {
28915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28916 }
28917 if (!argp2) {
28918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28919 }
28920 arg2 = reinterpret_cast< wxEvent * >(argp2);
28921 {
28922 PyThreadState* __tstate = wxPyBeginAllowThreads();
28923 wxPostEvent(arg1,*arg2);
28924 wxPyEndAllowThreads(__tstate);
28925 if (PyErr_Occurred()) SWIG_fail;
28926 }
28927 resultobj = SWIG_Py_Void();
28928 return resultobj;
28929 fail:
28930 return NULL;
28931 }
28932
28933
28934 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28935 PyObject *resultobj = 0;
28936
28937 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28938 {
28939 PyThreadState* __tstate = wxPyBeginAllowThreads();
28940 wxApp_CleanUp();
28941 wxPyEndAllowThreads(__tstate);
28942 if (PyErr_Occurred()) SWIG_fail;
28943 }
28944 resultobj = SWIG_Py_Void();
28945 return resultobj;
28946 fail:
28947 return NULL;
28948 }
28949
28950
28951 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28952 PyObject *resultobj = 0;
28953 wxPyApp *result = 0 ;
28954
28955 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28956 {
28957 PyThreadState* __tstate = wxPyBeginAllowThreads();
28958 result = (wxPyApp *)wxPyGetApp();
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 {
28963 resultobj = wxPyMake_wxObject(result, 0);
28964 }
28965 return resultobj;
28966 fail:
28967 return NULL;
28968 }
28969
28970
28971 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28972 PyObject *resultobj = 0;
28973 char *arg1 = (char *) 0 ;
28974 int res1 ;
28975 char *buf1 = 0 ;
28976 int alloc1 = 0 ;
28977 PyObject * obj0 = 0 ;
28978 char * kwnames[] = {
28979 (char *) "encoding", NULL
28980 };
28981
28982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28983 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28984 if (!SWIG_IsOK(res1)) {
28985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28986 }
28987 arg1 = buf1;
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 wxSetDefaultPyEncoding((char const *)arg1);
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 resultobj = SWIG_Py_Void();
28995 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28996 return resultobj;
28997 fail:
28998 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28999 return NULL;
29000 }
29001
29002
29003 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29004 PyObject *resultobj = 0;
29005 char *result = 0 ;
29006
29007 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29008 {
29009 PyThreadState* __tstate = wxPyBeginAllowThreads();
29010 result = (char *)wxGetDefaultPyEncoding();
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 resultobj = SWIG_FromCharPtr(result);
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29022 PyObject *resultobj = 0;
29023 wxEventLoop *result = 0 ;
29024
29025 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29026 {
29027 PyThreadState* __tstate = wxPyBeginAllowThreads();
29028 result = (wxEventLoop *)new wxEventLoop();
29029 wxPyEndAllowThreads(__tstate);
29030 if (PyErr_Occurred()) SWIG_fail;
29031 }
29032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29033 return resultobj;
29034 fail:
29035 return NULL;
29036 }
29037
29038
29039 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29040 PyObject *resultobj = 0;
29041 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject *swig_obj[1] ;
29045
29046 if (!args) SWIG_fail;
29047 swig_obj[0] = args;
29048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29051 }
29052 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 delete arg1;
29056
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 resultobj = SWIG_Py_Void();
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *resultobj = 0;
29069 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29070 int result;
29071 void *argp1 = 0 ;
29072 int res1 = 0 ;
29073 PyObject *swig_obj[1] ;
29074
29075 if (!args) SWIG_fail;
29076 swig_obj[0] = args;
29077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29080 }
29081 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 result = (int)(arg1)->Run();
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 resultobj = SWIG_From_int(static_cast< int >(result));
29089 return resultobj;
29090 fail:
29091 return NULL;
29092 }
29093
29094
29095 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29096 PyObject *resultobj = 0;
29097 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29098 int arg2 = (int) 0 ;
29099 void *argp1 = 0 ;
29100 int res1 = 0 ;
29101 int val2 ;
29102 int ecode2 = 0 ;
29103 PyObject * obj0 = 0 ;
29104 PyObject * obj1 = 0 ;
29105 char * kwnames[] = {
29106 (char *) "self",(char *) "rc", NULL
29107 };
29108
29109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29111 if (!SWIG_IsOK(res1)) {
29112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29113 }
29114 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29115 if (obj1) {
29116 ecode2 = SWIG_AsVal_int(obj1, &val2);
29117 if (!SWIG_IsOK(ecode2)) {
29118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29119 }
29120 arg2 = static_cast< int >(val2);
29121 }
29122 {
29123 PyThreadState* __tstate = wxPyBeginAllowThreads();
29124 (arg1)->Exit(arg2);
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_Py_Void();
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 PyObject *resultobj = 0;
29137 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29138 bool result;
29139 void *argp1 = 0 ;
29140 int res1 = 0 ;
29141 PyObject *swig_obj[1] ;
29142
29143 if (!args) SWIG_fail;
29144 swig_obj[0] = args;
29145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29146 if (!SWIG_IsOK(res1)) {
29147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29148 }
29149 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 result = (bool)((wxEventLoop const *)arg1)->Pending();
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 {
29157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29158 }
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29166 PyObject *resultobj = 0;
29167 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29168 bool result;
29169 void *argp1 = 0 ;
29170 int res1 = 0 ;
29171 PyObject *swig_obj[1] ;
29172
29173 if (!args) SWIG_fail;
29174 swig_obj[0] = args;
29175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29176 if (!SWIG_IsOK(res1)) {
29177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29178 }
29179 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29180 {
29181 PyThreadState* __tstate = wxPyBeginAllowThreads();
29182 result = (bool)(arg1)->Dispatch();
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 {
29187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29188 }
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29196 PyObject *resultobj = 0;
29197 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29198 bool result;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 PyObject *swig_obj[1] ;
29202
29203 if (!args) SWIG_fail;
29204 swig_obj[0] = args;
29205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29206 if (!SWIG_IsOK(res1)) {
29207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29208 }
29209 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29210 {
29211 PyThreadState* __tstate = wxPyBeginAllowThreads();
29212 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 {
29217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29218 }
29219 return resultobj;
29220 fail:
29221 return NULL;
29222 }
29223
29224
29225 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29226 PyObject *resultobj = 0;
29227 wxEventLoop *result = 0 ;
29228
29229 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29230 {
29231 PyThreadState* __tstate = wxPyBeginAllowThreads();
29232 result = (wxEventLoop *)wxEventLoop::GetActive();
29233 wxPyEndAllowThreads(__tstate);
29234 if (PyErr_Occurred()) SWIG_fail;
29235 }
29236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29237 return resultobj;
29238 fail:
29239 return NULL;
29240 }
29241
29242
29243 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29244 PyObject *resultobj = 0;
29245 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29246 void *argp1 = 0 ;
29247 int res1 = 0 ;
29248 PyObject * obj0 = 0 ;
29249 char * kwnames[] = {
29250 (char *) "loop", NULL
29251 };
29252
29253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29255 if (!SWIG_IsOK(res1)) {
29256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29257 }
29258 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 wxEventLoop::SetActive(arg1);
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 resultobj = SWIG_Py_Void();
29266 return resultobj;
29267 fail:
29268 return NULL;
29269 }
29270
29271
29272 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29273 PyObject *obj;
29274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29275 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29276 return SWIG_Py_Void();
29277 }
29278
29279 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 return SWIG_Python_InitShadowInstance(args);
29281 }
29282
29283 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj = 0;
29285 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29286 wxEventLoopActivator *result = 0 ;
29287 void *argp1 = 0 ;
29288 int res1 = 0 ;
29289 PyObject * obj0 = 0 ;
29290 char * kwnames[] = {
29291 (char *) "evtLoop", NULL
29292 };
29293
29294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29296 if (!SWIG_IsOK(res1)) {
29297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29298 }
29299 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29314 PyObject *resultobj = 0;
29315 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29316 void *argp1 = 0 ;
29317 int res1 = 0 ;
29318 PyObject *swig_obj[1] ;
29319
29320 if (!args) SWIG_fail;
29321 swig_obj[0] = args;
29322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29323 if (!SWIG_IsOK(res1)) {
29324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29325 }
29326 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29327 {
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 delete arg1;
29330
29331 wxPyEndAllowThreads(__tstate);
29332 if (PyErr_Occurred()) SWIG_fail;
29333 }
29334 resultobj = SWIG_Py_Void();
29335 return resultobj;
29336 fail:
29337 return NULL;
29338 }
29339
29340
29341 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29342 PyObject *obj;
29343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29344 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29345 return SWIG_Py_Void();
29346 }
29347
29348 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 return SWIG_Python_InitShadowInstance(args);
29350 }
29351
29352 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj = 0;
29354 int arg1 = (int) 0 ;
29355 int arg2 = (int) 0 ;
29356 int arg3 = (int) 0 ;
29357 wxAcceleratorEntry *result = 0 ;
29358 int val1 ;
29359 int ecode1 = 0 ;
29360 int val2 ;
29361 int ecode2 = 0 ;
29362 int val3 ;
29363 int ecode3 = 0 ;
29364 PyObject * obj0 = 0 ;
29365 PyObject * obj1 = 0 ;
29366 PyObject * obj2 = 0 ;
29367 char * kwnames[] = {
29368 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29369 };
29370
29371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29372 if (obj0) {
29373 ecode1 = SWIG_AsVal_int(obj0, &val1);
29374 if (!SWIG_IsOK(ecode1)) {
29375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29376 }
29377 arg1 = static_cast< int >(val1);
29378 }
29379 if (obj1) {
29380 ecode2 = SWIG_AsVal_int(obj1, &val2);
29381 if (!SWIG_IsOK(ecode2)) {
29382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29383 }
29384 arg2 = static_cast< int >(val2);
29385 }
29386 if (obj2) {
29387 ecode3 = SWIG_AsVal_int(obj2, &val3);
29388 if (!SWIG_IsOK(ecode3)) {
29389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29390 }
29391 arg3 = static_cast< int >(val3);
29392 }
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29407 PyObject *resultobj = 0;
29408 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29409 void *argp1 = 0 ;
29410 int res1 = 0 ;
29411 PyObject *swig_obj[1] ;
29412
29413 if (!args) SWIG_fail;
29414 swig_obj[0] = args;
29415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29416 if (!SWIG_IsOK(res1)) {
29417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29418 }
29419 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29420 {
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 delete arg1;
29423
29424 wxPyEndAllowThreads(__tstate);
29425 if (PyErr_Occurred()) SWIG_fail;
29426 }
29427 resultobj = SWIG_Py_Void();
29428 return resultobj;
29429 fail:
29430 return NULL;
29431 }
29432
29433
29434 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29435 PyObject *resultobj = 0;
29436 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29437 int arg2 ;
29438 int arg3 ;
29439 int arg4 ;
29440 void *argp1 = 0 ;
29441 int res1 = 0 ;
29442 int val2 ;
29443 int ecode2 = 0 ;
29444 int val3 ;
29445 int ecode3 = 0 ;
29446 int val4 ;
29447 int ecode4 = 0 ;
29448 PyObject * obj0 = 0 ;
29449 PyObject * obj1 = 0 ;
29450 PyObject * obj2 = 0 ;
29451 PyObject * obj3 = 0 ;
29452 char * kwnames[] = {
29453 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29454 };
29455
29456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29458 if (!SWIG_IsOK(res1)) {
29459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29460 }
29461 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29462 ecode2 = SWIG_AsVal_int(obj1, &val2);
29463 if (!SWIG_IsOK(ecode2)) {
29464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29465 }
29466 arg2 = static_cast< int >(val2);
29467 ecode3 = SWIG_AsVal_int(obj2, &val3);
29468 if (!SWIG_IsOK(ecode3)) {
29469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29470 }
29471 arg3 = static_cast< int >(val3);
29472 ecode4 = SWIG_AsVal_int(obj3, &val4);
29473 if (!SWIG_IsOK(ecode4)) {
29474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29475 }
29476 arg4 = static_cast< int >(val4);
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 (arg1)->Set(arg2,arg3,arg4);
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 resultobj = SWIG_Py_Void();
29484 return resultobj;
29485 fail:
29486 return NULL;
29487 }
29488
29489
29490 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29491 PyObject *resultobj = 0;
29492 wxString *arg1 = 0 ;
29493 wxAcceleratorEntry *result = 0 ;
29494 bool temp1 = false ;
29495 PyObject * obj0 = 0 ;
29496 char * kwnames[] = {
29497 (char *) "str", NULL
29498 };
29499
29500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29501 {
29502 arg1 = wxString_in_helper(obj0);
29503 if (arg1 == NULL) SWIG_fail;
29504 temp1 = true;
29505 }
29506 {
29507 PyThreadState* __tstate = wxPyBeginAllowThreads();
29508 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29509 wxPyEndAllowThreads(__tstate);
29510 if (PyErr_Occurred()) SWIG_fail;
29511 }
29512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29513 {
29514 if (temp1)
29515 delete arg1;
29516 }
29517 return resultobj;
29518 fail:
29519 {
29520 if (temp1)
29521 delete arg1;
29522 }
29523 return NULL;
29524 }
29525
29526
29527 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29528 PyObject *resultobj = 0;
29529 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29530 int result;
29531 void *argp1 = 0 ;
29532 int res1 = 0 ;
29533 PyObject *swig_obj[1] ;
29534
29535 if (!args) SWIG_fail;
29536 swig_obj[0] = args;
29537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29538 if (!SWIG_IsOK(res1)) {
29539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29540 }
29541 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 result = (int)(arg1)->GetFlags();
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 resultobj = SWIG_From_int(static_cast< int >(result));
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29556 PyObject *resultobj = 0;
29557 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29558 int result;
29559 void *argp1 = 0 ;
29560 int res1 = 0 ;
29561 PyObject *swig_obj[1] ;
29562
29563 if (!args) SWIG_fail;
29564 swig_obj[0] = args;
29565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29566 if (!SWIG_IsOK(res1)) {
29567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29568 }
29569 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 result = (int)(arg1)->GetKeyCode();
29573 wxPyEndAllowThreads(__tstate);
29574 if (PyErr_Occurred()) SWIG_fail;
29575 }
29576 resultobj = SWIG_From_int(static_cast< int >(result));
29577 return resultobj;
29578 fail:
29579 return NULL;
29580 }
29581
29582
29583 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29584 PyObject *resultobj = 0;
29585 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29586 int result;
29587 void *argp1 = 0 ;
29588 int res1 = 0 ;
29589 PyObject *swig_obj[1] ;
29590
29591 if (!args) SWIG_fail;
29592 swig_obj[0] = args;
29593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29594 if (!SWIG_IsOK(res1)) {
29595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29596 }
29597 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 result = (int)(arg1)->GetCommand();
29601 wxPyEndAllowThreads(__tstate);
29602 if (PyErr_Occurred()) SWIG_fail;
29603 }
29604 resultobj = SWIG_From_int(static_cast< int >(result));
29605 return resultobj;
29606 fail:
29607 return NULL;
29608 }
29609
29610
29611 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29612 PyObject *resultobj = 0;
29613 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29614 bool result;
29615 void *argp1 = 0 ;
29616 int res1 = 0 ;
29617 PyObject *swig_obj[1] ;
29618
29619 if (!args) SWIG_fail;
29620 swig_obj[0] = args;
29621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29622 if (!SWIG_IsOK(res1)) {
29623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29624 }
29625 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29629 wxPyEndAllowThreads(__tstate);
29630 if (PyErr_Occurred()) SWIG_fail;
29631 }
29632 {
29633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29634 }
29635 return resultobj;
29636 fail:
29637 return NULL;
29638 }
29639
29640
29641 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29642 PyObject *resultobj = 0;
29643 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29644 wxString result;
29645 void *argp1 = 0 ;
29646 int res1 = 0 ;
29647 PyObject *swig_obj[1] ;
29648
29649 if (!args) SWIG_fail;
29650 swig_obj[0] = args;
29651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29652 if (!SWIG_IsOK(res1)) {
29653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29654 }
29655 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29656 {
29657 PyThreadState* __tstate = wxPyBeginAllowThreads();
29658 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29659 wxPyEndAllowThreads(__tstate);
29660 if (PyErr_Occurred()) SWIG_fail;
29661 }
29662 {
29663 #if wxUSE_UNICODE
29664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29665 #else
29666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29667 #endif
29668 }
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29676 PyObject *resultobj = 0;
29677 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29678 wxString *arg2 = 0 ;
29679 bool result;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 bool temp2 = false ;
29683 PyObject * obj0 = 0 ;
29684 PyObject * obj1 = 0 ;
29685 char * kwnames[] = {
29686 (char *) "self",(char *) "str", NULL
29687 };
29688
29689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29691 if (!SWIG_IsOK(res1)) {
29692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29693 }
29694 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29695 {
29696 arg2 = wxString_in_helper(obj1);
29697 if (arg2 == NULL) SWIG_fail;
29698 temp2 = true;
29699 }
29700 {
29701 PyThreadState* __tstate = wxPyBeginAllowThreads();
29702 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29703 wxPyEndAllowThreads(__tstate);
29704 if (PyErr_Occurred()) SWIG_fail;
29705 }
29706 {
29707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29708 }
29709 {
29710 if (temp2)
29711 delete arg2;
29712 }
29713 return resultobj;
29714 fail:
29715 {
29716 if (temp2)
29717 delete arg2;
29718 }
29719 return NULL;
29720 }
29721
29722
29723 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29724 PyObject *obj;
29725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29726 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29727 return SWIG_Py_Void();
29728 }
29729
29730 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29731 return SWIG_Python_InitShadowInstance(args);
29732 }
29733
29734 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29735 PyObject *resultobj = 0;
29736 int arg1 ;
29737 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29738 wxAcceleratorTable *result = 0 ;
29739 PyObject * obj0 = 0 ;
29740 char * kwnames[] = {
29741 (char *) "n", NULL
29742 };
29743
29744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29745 {
29746 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29747 if (arg2) arg1 = PyList_Size(obj0);
29748 else arg1 = 0;
29749 }
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *resultobj = 0;
29765 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29766 void *argp1 = 0 ;
29767 int res1 = 0 ;
29768 PyObject *swig_obj[1] ;
29769
29770 if (!args) SWIG_fail;
29771 swig_obj[0] = args;
29772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29773 if (!SWIG_IsOK(res1)) {
29774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29775 }
29776 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29777 {
29778 PyThreadState* __tstate = wxPyBeginAllowThreads();
29779 delete arg1;
29780
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 resultobj = SWIG_Py_Void();
29785 return resultobj;
29786 fail:
29787 return NULL;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29792 PyObject *resultobj = 0;
29793 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29794 bool result;
29795 void *argp1 = 0 ;
29796 int res1 = 0 ;
29797 PyObject *swig_obj[1] ;
29798
29799 if (!args) SWIG_fail;
29800 swig_obj[0] = args;
29801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29802 if (!SWIG_IsOK(res1)) {
29803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29804 }
29805 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29806 {
29807 PyThreadState* __tstate = wxPyBeginAllowThreads();
29808 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29809 wxPyEndAllowThreads(__tstate);
29810 if (PyErr_Occurred()) SWIG_fail;
29811 }
29812 {
29813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29814 }
29815 return resultobj;
29816 fail:
29817 return NULL;
29818 }
29819
29820
29821 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29822 PyObject *obj;
29823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29824 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29825 return SWIG_Py_Void();
29826 }
29827
29828 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29829 return SWIG_Python_InitShadowInstance(args);
29830 }
29831
29832 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29833 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29834 return 1;
29835 }
29836
29837
29838 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29839 PyObject *pyobj = 0;
29840
29841 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29842 return pyobj;
29843 }
29844
29845
29846 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29847 PyObject *resultobj = 0;
29848 wxString *arg1 = 0 ;
29849 wxAcceleratorEntry *result = 0 ;
29850 bool temp1 = false ;
29851 PyObject * obj0 = 0 ;
29852 char * kwnames[] = {
29853 (char *) "label", NULL
29854 };
29855
29856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29857 {
29858 arg1 = wxString_in_helper(obj0);
29859 if (arg1 == NULL) SWIG_fail;
29860 temp1 = true;
29861 }
29862 {
29863 PyThreadState* __tstate = wxPyBeginAllowThreads();
29864 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29869 {
29870 if (temp1)
29871 delete arg1;
29872 }
29873 return resultobj;
29874 fail:
29875 {
29876 if (temp1)
29877 delete arg1;
29878 }
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN int PanelNameStr_set(PyObject *) {
29884 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29885 return 1;
29886 }
29887
29888
29889 SWIGINTERN PyObject *PanelNameStr_get(void) {
29890 PyObject *pyobj = 0;
29891
29892 {
29893 #if wxUSE_UNICODE
29894 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29895 #else
29896 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29897 #endif
29898 }
29899 return pyobj;
29900 }
29901
29902
29903 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29904 PyObject *resultobj = 0;
29905 wxVisualAttributes *result = 0 ;
29906
29907 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29908 {
29909 PyThreadState* __tstate = wxPyBeginAllowThreads();
29910 result = (wxVisualAttributes *)new_wxVisualAttributes();
29911 wxPyEndAllowThreads(__tstate);
29912 if (PyErr_Occurred()) SWIG_fail;
29913 }
29914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29915 return resultobj;
29916 fail:
29917 return NULL;
29918 }
29919
29920
29921 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29922 PyObject *resultobj = 0;
29923 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29924 void *argp1 = 0 ;
29925 int res1 = 0 ;
29926 PyObject *swig_obj[1] ;
29927
29928 if (!args) SWIG_fail;
29929 swig_obj[0] = args;
29930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29931 if (!SWIG_IsOK(res1)) {
29932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29933 }
29934 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29935 {
29936 PyThreadState* __tstate = wxPyBeginAllowThreads();
29937 delete_wxVisualAttributes(arg1);
29938
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 resultobj = SWIG_Py_Void();
29943 return resultobj;
29944 fail:
29945 return NULL;
29946 }
29947
29948
29949 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29950 PyObject *resultobj = 0;
29951 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29952 wxFont *arg2 = (wxFont *) 0 ;
29953 void *argp1 = 0 ;
29954 int res1 = 0 ;
29955 void *argp2 = 0 ;
29956 int res2 = 0 ;
29957 PyObject *swig_obj[2] ;
29958
29959 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29961 if (!SWIG_IsOK(res1)) {
29962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29963 }
29964 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29965 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29966 if (!SWIG_IsOK(res2)) {
29967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29968 }
29969 arg2 = reinterpret_cast< wxFont * >(argp2);
29970 if (arg1) (arg1)->font = *arg2;
29971
29972 resultobj = SWIG_Py_Void();
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29980 PyObject *resultobj = 0;
29981 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29982 wxFont *result = 0 ;
29983 void *argp1 = 0 ;
29984 int res1 = 0 ;
29985 PyObject *swig_obj[1] ;
29986
29987 if (!args) SWIG_fail;
29988 swig_obj[0] = args;
29989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29990 if (!SWIG_IsOK(res1)) {
29991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29992 }
29993 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29994 result = (wxFont *)& ((arg1)->font);
29995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29996 return resultobj;
29997 fail:
29998 return NULL;
29999 }
30000
30001
30002 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 PyObject *resultobj = 0;
30004 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30005 wxColour *arg2 = (wxColour *) 0 ;
30006 void *argp1 = 0 ;
30007 int res1 = 0 ;
30008 void *argp2 = 0 ;
30009 int res2 = 0 ;
30010 PyObject *swig_obj[2] ;
30011
30012 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30014 if (!SWIG_IsOK(res1)) {
30015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30016 }
30017 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30018 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30019 if (!SWIG_IsOK(res2)) {
30020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30021 }
30022 arg2 = reinterpret_cast< wxColour * >(argp2);
30023 if (arg1) (arg1)->colFg = *arg2;
30024
30025 resultobj = SWIG_Py_Void();
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30033 PyObject *resultobj = 0;
30034 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30035 wxColour *result = 0 ;
30036 void *argp1 = 0 ;
30037 int res1 = 0 ;
30038 PyObject *swig_obj[1] ;
30039
30040 if (!args) SWIG_fail;
30041 swig_obj[0] = args;
30042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30043 if (!SWIG_IsOK(res1)) {
30044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30045 }
30046 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30047 result = (wxColour *)& ((arg1)->colFg);
30048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30056 PyObject *resultobj = 0;
30057 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30058 wxColour *arg2 = (wxColour *) 0 ;
30059 void *argp1 = 0 ;
30060 int res1 = 0 ;
30061 void *argp2 = 0 ;
30062 int res2 = 0 ;
30063 PyObject *swig_obj[2] ;
30064
30065 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30067 if (!SWIG_IsOK(res1)) {
30068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30069 }
30070 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30071 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30072 if (!SWIG_IsOK(res2)) {
30073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30074 }
30075 arg2 = reinterpret_cast< wxColour * >(argp2);
30076 if (arg1) (arg1)->colBg = *arg2;
30077
30078 resultobj = SWIG_Py_Void();
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30086 PyObject *resultobj = 0;
30087 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30088 wxColour *result = 0 ;
30089 void *argp1 = 0 ;
30090 int res1 = 0 ;
30091 PyObject *swig_obj[1] ;
30092
30093 if (!args) SWIG_fail;
30094 swig_obj[0] = args;
30095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30096 if (!SWIG_IsOK(res1)) {
30097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30098 }
30099 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30100 result = (wxColour *)& ((arg1)->colBg);
30101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30109 PyObject *obj;
30110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30111 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30112 return SWIG_Py_Void();
30113 }
30114
30115 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30116 return SWIG_Python_InitShadowInstance(args);
30117 }
30118
30119 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj = 0;
30121 wxWindow *arg1 = (wxWindow *) 0 ;
30122 int arg2 = (int) (int)-1 ;
30123 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30124 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30125 wxSize const &arg4_defvalue = wxDefaultSize ;
30126 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30127 long arg5 = (long) 0 ;
30128 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30129 wxString *arg6 = (wxString *) &arg6_defvalue ;
30130 wxWindow *result = 0 ;
30131 void *argp1 = 0 ;
30132 int res1 = 0 ;
30133 int val2 ;
30134 int ecode2 = 0 ;
30135 wxPoint temp3 ;
30136 wxSize temp4 ;
30137 long val5 ;
30138 int ecode5 = 0 ;
30139 bool temp6 = false ;
30140 PyObject * obj0 = 0 ;
30141 PyObject * obj1 = 0 ;
30142 PyObject * obj2 = 0 ;
30143 PyObject * obj3 = 0 ;
30144 PyObject * obj4 = 0 ;
30145 PyObject * obj5 = 0 ;
30146 char * kwnames[] = {
30147 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30148 };
30149
30150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30152 if (!SWIG_IsOK(res1)) {
30153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30154 }
30155 arg1 = reinterpret_cast< wxWindow * >(argp1);
30156 if (obj1) {
30157 ecode2 = SWIG_AsVal_int(obj1, &val2);
30158 if (!SWIG_IsOK(ecode2)) {
30159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30160 }
30161 arg2 = static_cast< int >(val2);
30162 }
30163 if (obj2) {
30164 {
30165 arg3 = &temp3;
30166 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30167 }
30168 }
30169 if (obj3) {
30170 {
30171 arg4 = &temp4;
30172 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30173 }
30174 }
30175 if (obj4) {
30176 ecode5 = SWIG_AsVal_long(obj4, &val5);
30177 if (!SWIG_IsOK(ecode5)) {
30178 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30179 }
30180 arg5 = static_cast< long >(val5);
30181 }
30182 if (obj5) {
30183 {
30184 arg6 = wxString_in_helper(obj5);
30185 if (arg6 == NULL) SWIG_fail;
30186 temp6 = true;
30187 }
30188 }
30189 {
30190 if (!wxPyCheckForApp()) SWIG_fail;
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30197 {
30198 if (temp6)
30199 delete arg6;
30200 }
30201 return resultobj;
30202 fail:
30203 {
30204 if (temp6)
30205 delete arg6;
30206 }
30207 return NULL;
30208 }
30209
30210
30211 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30212 PyObject *resultobj = 0;
30213 wxWindow *result = 0 ;
30214
30215 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30216 {
30217 if (!wxPyCheckForApp()) SWIG_fail;
30218 PyThreadState* __tstate = wxPyBeginAllowThreads();
30219 result = (wxWindow *)new wxWindow();
30220 wxPyEndAllowThreads(__tstate);
30221 if (PyErr_Occurred()) SWIG_fail;
30222 }
30223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30231 PyObject *resultobj = 0;
30232 wxWindow *arg1 = (wxWindow *) 0 ;
30233 wxWindow *arg2 = (wxWindow *) 0 ;
30234 int arg3 = (int) (int)-1 ;
30235 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30236 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30237 wxSize const &arg5_defvalue = wxDefaultSize ;
30238 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30239 long arg6 = (long) 0 ;
30240 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30241 wxString *arg7 = (wxString *) &arg7_defvalue ;
30242 bool result;
30243 void *argp1 = 0 ;
30244 int res1 = 0 ;
30245 void *argp2 = 0 ;
30246 int res2 = 0 ;
30247 int val3 ;
30248 int ecode3 = 0 ;
30249 wxPoint temp4 ;
30250 wxSize temp5 ;
30251 long val6 ;
30252 int ecode6 = 0 ;
30253 bool temp7 = false ;
30254 PyObject * obj0 = 0 ;
30255 PyObject * obj1 = 0 ;
30256 PyObject * obj2 = 0 ;
30257 PyObject * obj3 = 0 ;
30258 PyObject * obj4 = 0 ;
30259 PyObject * obj5 = 0 ;
30260 PyObject * obj6 = 0 ;
30261 char * kwnames[] = {
30262 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30263 };
30264
30265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30267 if (!SWIG_IsOK(res1)) {
30268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30269 }
30270 arg1 = reinterpret_cast< wxWindow * >(argp1);
30271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30272 if (!SWIG_IsOK(res2)) {
30273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30274 }
30275 arg2 = reinterpret_cast< wxWindow * >(argp2);
30276 if (obj2) {
30277 ecode3 = SWIG_AsVal_int(obj2, &val3);
30278 if (!SWIG_IsOK(ecode3)) {
30279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30280 }
30281 arg3 = static_cast< int >(val3);
30282 }
30283 if (obj3) {
30284 {
30285 arg4 = &temp4;
30286 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30287 }
30288 }
30289 if (obj4) {
30290 {
30291 arg5 = &temp5;
30292 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30293 }
30294 }
30295 if (obj5) {
30296 ecode6 = SWIG_AsVal_long(obj5, &val6);
30297 if (!SWIG_IsOK(ecode6)) {
30298 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30299 }
30300 arg6 = static_cast< long >(val6);
30301 }
30302 if (obj6) {
30303 {
30304 arg7 = wxString_in_helper(obj6);
30305 if (arg7 == NULL) SWIG_fail;
30306 temp7 = true;
30307 }
30308 }
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30312 wxPyEndAllowThreads(__tstate);
30313 if (PyErr_Occurred()) SWIG_fail;
30314 }
30315 {
30316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30317 }
30318 {
30319 if (temp7)
30320 delete arg7;
30321 }
30322 return resultobj;
30323 fail:
30324 {
30325 if (temp7)
30326 delete arg7;
30327 }
30328 return NULL;
30329 }
30330
30331
30332 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30333 PyObject *resultobj = 0;
30334 wxWindow *arg1 = (wxWindow *) 0 ;
30335 bool arg2 = (bool) false ;
30336 bool result;
30337 void *argp1 = 0 ;
30338 int res1 = 0 ;
30339 bool val2 ;
30340 int ecode2 = 0 ;
30341 PyObject * obj0 = 0 ;
30342 PyObject * obj1 = 0 ;
30343 char * kwnames[] = {
30344 (char *) "self",(char *) "force", NULL
30345 };
30346
30347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30349 if (!SWIG_IsOK(res1)) {
30350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30351 }
30352 arg1 = reinterpret_cast< wxWindow * >(argp1);
30353 if (obj1) {
30354 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30355 if (!SWIG_IsOK(ecode2)) {
30356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30357 }
30358 arg2 = static_cast< bool >(val2);
30359 }
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 result = (bool)(arg1)->Close(arg2);
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 {
30367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30368 }
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30376 PyObject *resultobj = 0;
30377 wxWindow *arg1 = (wxWindow *) 0 ;
30378 bool result;
30379 void *argp1 = 0 ;
30380 int res1 = 0 ;
30381 PyObject *swig_obj[1] ;
30382
30383 if (!args) SWIG_fail;
30384 swig_obj[0] = args;
30385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30386 if (!SWIG_IsOK(res1)) {
30387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30388 }
30389 arg1 = reinterpret_cast< wxWindow * >(argp1);
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 result = (bool)(arg1)->Destroy();
30393 wxPyEndAllowThreads(__tstate);
30394 if (PyErr_Occurred()) SWIG_fail;
30395 }
30396 {
30397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30398 }
30399 return resultobj;
30400 fail:
30401 return NULL;
30402 }
30403
30404
30405 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30406 PyObject *resultobj = 0;
30407 wxWindow *arg1 = (wxWindow *) 0 ;
30408 bool result;
30409 void *argp1 = 0 ;
30410 int res1 = 0 ;
30411 PyObject *swig_obj[1] ;
30412
30413 if (!args) SWIG_fail;
30414 swig_obj[0] = args;
30415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30416 if (!SWIG_IsOK(res1)) {
30417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30418 }
30419 arg1 = reinterpret_cast< wxWindow * >(argp1);
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 result = (bool)(arg1)->DestroyChildren();
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 {
30427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30428 }
30429 return resultobj;
30430 fail:
30431 return NULL;
30432 }
30433
30434
30435 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30436 PyObject *resultobj = 0;
30437 wxWindow *arg1 = (wxWindow *) 0 ;
30438 bool result;
30439 void *argp1 = 0 ;
30440 int res1 = 0 ;
30441 PyObject *swig_obj[1] ;
30442
30443 if (!args) SWIG_fail;
30444 swig_obj[0] = args;
30445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30446 if (!SWIG_IsOK(res1)) {
30447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30448 }
30449 arg1 = reinterpret_cast< wxWindow * >(argp1);
30450 {
30451 PyThreadState* __tstate = wxPyBeginAllowThreads();
30452 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30453 wxPyEndAllowThreads(__tstate);
30454 if (PyErr_Occurred()) SWIG_fail;
30455 }
30456 {
30457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30458 }
30459 return resultobj;
30460 fail:
30461 return NULL;
30462 }
30463
30464
30465 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30466 PyObject *resultobj = 0;
30467 wxWindow *arg1 = (wxWindow *) 0 ;
30468 wxString *arg2 = 0 ;
30469 void *argp1 = 0 ;
30470 int res1 = 0 ;
30471 bool temp2 = false ;
30472 PyObject * obj0 = 0 ;
30473 PyObject * obj1 = 0 ;
30474 char * kwnames[] = {
30475 (char *) "self",(char *) "label", NULL
30476 };
30477
30478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30480 if (!SWIG_IsOK(res1)) {
30481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30482 }
30483 arg1 = reinterpret_cast< wxWindow * >(argp1);
30484 {
30485 arg2 = wxString_in_helper(obj1);
30486 if (arg2 == NULL) SWIG_fail;
30487 temp2 = true;
30488 }
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 (arg1)->SetLabel((wxString const &)*arg2);
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_Py_Void();
30496 {
30497 if (temp2)
30498 delete arg2;
30499 }
30500 return resultobj;
30501 fail:
30502 {
30503 if (temp2)
30504 delete arg2;
30505 }
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxWindow *arg1 = (wxWindow *) 0 ;
30513 wxString result;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 PyObject *swig_obj[1] ;
30517
30518 if (!args) SWIG_fail;
30519 swig_obj[0] = args;
30520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30521 if (!SWIG_IsOK(res1)) {
30522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30523 }
30524 arg1 = reinterpret_cast< wxWindow * >(argp1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = ((wxWindow const *)arg1)->GetLabel();
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 {
30532 #if wxUSE_UNICODE
30533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30534 #else
30535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30536 #endif
30537 }
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj = 0;
30546 wxWindow *arg1 = (wxWindow *) 0 ;
30547 wxString *arg2 = 0 ;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 bool temp2 = false ;
30551 PyObject * obj0 = 0 ;
30552 PyObject * obj1 = 0 ;
30553 char * kwnames[] = {
30554 (char *) "self",(char *) "name", NULL
30555 };
30556
30557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30559 if (!SWIG_IsOK(res1)) {
30560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30561 }
30562 arg1 = reinterpret_cast< wxWindow * >(argp1);
30563 {
30564 arg2 = wxString_in_helper(obj1);
30565 if (arg2 == NULL) SWIG_fail;
30566 temp2 = true;
30567 }
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->SetName((wxString const &)*arg2);
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 {
30576 if (temp2)
30577 delete arg2;
30578 }
30579 return resultobj;
30580 fail:
30581 {
30582 if (temp2)
30583 delete arg2;
30584 }
30585 return NULL;
30586 }
30587
30588
30589 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30590 PyObject *resultobj = 0;
30591 wxWindow *arg1 = (wxWindow *) 0 ;
30592 wxString result;
30593 void *argp1 = 0 ;
30594 int res1 = 0 ;
30595 PyObject *swig_obj[1] ;
30596
30597 if (!args) SWIG_fail;
30598 swig_obj[0] = args;
30599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30600 if (!SWIG_IsOK(res1)) {
30601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30602 }
30603 arg1 = reinterpret_cast< wxWindow * >(argp1);
30604 {
30605 PyThreadState* __tstate = wxPyBeginAllowThreads();
30606 result = ((wxWindow const *)arg1)->GetName();
30607 wxPyEndAllowThreads(__tstate);
30608 if (PyErr_Occurred()) SWIG_fail;
30609 }
30610 {
30611 #if wxUSE_UNICODE
30612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30613 #else
30614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30615 #endif
30616 }
30617 return resultobj;
30618 fail:
30619 return NULL;
30620 }
30621
30622
30623 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30624 PyObject *resultobj = 0;
30625 wxWindow *arg1 = (wxWindow *) 0 ;
30626 wxWindowVariant arg2 ;
30627 void *argp1 = 0 ;
30628 int res1 = 0 ;
30629 int val2 ;
30630 int ecode2 = 0 ;
30631 PyObject * obj0 = 0 ;
30632 PyObject * obj1 = 0 ;
30633 char * kwnames[] = {
30634 (char *) "self",(char *) "variant", NULL
30635 };
30636
30637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30639 if (!SWIG_IsOK(res1)) {
30640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30641 }
30642 arg1 = reinterpret_cast< wxWindow * >(argp1);
30643 ecode2 = SWIG_AsVal_int(obj1, &val2);
30644 if (!SWIG_IsOK(ecode2)) {
30645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30646 }
30647 arg2 = static_cast< wxWindowVariant >(val2);
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 (arg1)->SetWindowVariant(arg2);
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 resultobj = SWIG_Py_Void();
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30662 PyObject *resultobj = 0;
30663 wxWindow *arg1 = (wxWindow *) 0 ;
30664 wxWindowVariant result;
30665 void *argp1 = 0 ;
30666 int res1 = 0 ;
30667 PyObject *swig_obj[1] ;
30668
30669 if (!args) SWIG_fail;
30670 swig_obj[0] = args;
30671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30672 if (!SWIG_IsOK(res1)) {
30673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30674 }
30675 arg1 = reinterpret_cast< wxWindow * >(argp1);
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 resultobj = SWIG_From_int(static_cast< int >(result));
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj = 0;
30691 wxWindow *arg1 = (wxWindow *) 0 ;
30692 int arg2 ;
30693 void *argp1 = 0 ;
30694 int res1 = 0 ;
30695 int val2 ;
30696 int ecode2 = 0 ;
30697 PyObject * obj0 = 0 ;
30698 PyObject * obj1 = 0 ;
30699 char * kwnames[] = {
30700 (char *) "self",(char *) "winid", NULL
30701 };
30702
30703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30705 if (!SWIG_IsOK(res1)) {
30706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30707 }
30708 arg1 = reinterpret_cast< wxWindow * >(argp1);
30709 ecode2 = SWIG_AsVal_int(obj1, &val2);
30710 if (!SWIG_IsOK(ecode2)) {
30711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30712 }
30713 arg2 = static_cast< int >(val2);
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 (arg1)->SetId(arg2);
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 resultobj = SWIG_Py_Void();
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30728 PyObject *resultobj = 0;
30729 wxWindow *arg1 = (wxWindow *) 0 ;
30730 int result;
30731 void *argp1 = 0 ;
30732 int res1 = 0 ;
30733 PyObject *swig_obj[1] ;
30734
30735 if (!args) SWIG_fail;
30736 swig_obj[0] = args;
30737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30740 }
30741 arg1 = reinterpret_cast< wxWindow * >(argp1);
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 result = (int)((wxWindow const *)arg1)->GetId();
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 resultobj = SWIG_From_int(static_cast< int >(result));
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30756 PyObject *resultobj = 0;
30757 int result;
30758
30759 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 result = (int)wxWindow::NewControlId();
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 resultobj = SWIG_From_int(static_cast< int >(result));
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30774 PyObject *resultobj = 0;
30775 int arg1 ;
30776 int result;
30777 int val1 ;
30778 int ecode1 = 0 ;
30779 PyObject * obj0 = 0 ;
30780 char * kwnames[] = {
30781 (char *) "winid", NULL
30782 };
30783
30784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30785 ecode1 = SWIG_AsVal_int(obj0, &val1);
30786 if (!SWIG_IsOK(ecode1)) {
30787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30788 }
30789 arg1 = static_cast< int >(val1);
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 result = (int)wxWindow::NextControlId(arg1);
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 resultobj = SWIG_From_int(static_cast< int >(result));
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30804 PyObject *resultobj = 0;
30805 int arg1 ;
30806 int result;
30807 int val1 ;
30808 int ecode1 = 0 ;
30809 PyObject * obj0 = 0 ;
30810 char * kwnames[] = {
30811 (char *) "winid", NULL
30812 };
30813
30814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30815 ecode1 = SWIG_AsVal_int(obj0, &val1);
30816 if (!SWIG_IsOK(ecode1)) {
30817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30818 }
30819 arg1 = static_cast< int >(val1);
30820 {
30821 PyThreadState* __tstate = wxPyBeginAllowThreads();
30822 result = (int)wxWindow::PrevControlId(arg1);
30823 wxPyEndAllowThreads(__tstate);
30824 if (PyErr_Occurred()) SWIG_fail;
30825 }
30826 resultobj = SWIG_From_int(static_cast< int >(result));
30827 return resultobj;
30828 fail:
30829 return NULL;
30830 }
30831
30832
30833 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30834 PyObject *resultobj = 0;
30835 wxWindow *arg1 = (wxWindow *) 0 ;
30836 wxLayoutDirection result;
30837 void *argp1 = 0 ;
30838 int res1 = 0 ;
30839 PyObject *swig_obj[1] ;
30840
30841 if (!args) SWIG_fail;
30842 swig_obj[0] = args;
30843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30844 if (!SWIG_IsOK(res1)) {
30845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30846 }
30847 arg1 = reinterpret_cast< wxWindow * >(argp1);
30848 {
30849 PyThreadState* __tstate = wxPyBeginAllowThreads();
30850 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
30851 wxPyEndAllowThreads(__tstate);
30852 if (PyErr_Occurred()) SWIG_fail;
30853 }
30854 resultobj = SWIG_From_int(static_cast< int >(result));
30855 return resultobj;
30856 fail:
30857 return NULL;
30858 }
30859
30860
30861 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30862 PyObject *resultobj = 0;
30863 wxWindow *arg1 = (wxWindow *) 0 ;
30864 wxLayoutDirection arg2 ;
30865 void *argp1 = 0 ;
30866 int res1 = 0 ;
30867 int val2 ;
30868 int ecode2 = 0 ;
30869 PyObject * obj0 = 0 ;
30870 PyObject * obj1 = 0 ;
30871 char * kwnames[] = {
30872 (char *) "self",(char *) "dir", NULL
30873 };
30874
30875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30879 }
30880 arg1 = reinterpret_cast< wxWindow * >(argp1);
30881 ecode2 = SWIG_AsVal_int(obj1, &val2);
30882 if (!SWIG_IsOK(ecode2)) {
30883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30884 }
30885 arg2 = static_cast< wxLayoutDirection >(val2);
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 (arg1)->SetLayoutDirection(arg2);
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 resultobj = SWIG_Py_Void();
30893 return resultobj;
30894 fail:
30895 return NULL;
30896 }
30897
30898
30899 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30900 PyObject *resultobj = 0;
30901 wxWindow *arg1 = (wxWindow *) 0 ;
30902 int arg2 ;
30903 int arg3 ;
30904 int arg4 ;
30905 int result;
30906 void *argp1 = 0 ;
30907 int res1 = 0 ;
30908 int val2 ;
30909 int ecode2 = 0 ;
30910 int val3 ;
30911 int ecode3 = 0 ;
30912 int val4 ;
30913 int ecode4 = 0 ;
30914 PyObject * obj0 = 0 ;
30915 PyObject * obj1 = 0 ;
30916 PyObject * obj2 = 0 ;
30917 PyObject * obj3 = 0 ;
30918 char * kwnames[] = {
30919 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30920 };
30921
30922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30924 if (!SWIG_IsOK(res1)) {
30925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30926 }
30927 arg1 = reinterpret_cast< wxWindow * >(argp1);
30928 ecode2 = SWIG_AsVal_int(obj1, &val2);
30929 if (!SWIG_IsOK(ecode2)) {
30930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30931 }
30932 arg2 = static_cast< int >(val2);
30933 ecode3 = SWIG_AsVal_int(obj2, &val3);
30934 if (!SWIG_IsOK(ecode3)) {
30935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30936 }
30937 arg3 = static_cast< int >(val3);
30938 ecode4 = SWIG_AsVal_int(obj3, &val4);
30939 if (!SWIG_IsOK(ecode4)) {
30940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30941 }
30942 arg4 = static_cast< int >(val4);
30943 {
30944 PyThreadState* __tstate = wxPyBeginAllowThreads();
30945 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 resultobj = SWIG_From_int(static_cast< int >(result));
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj = 0;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 wxSize *arg2 = 0 ;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 wxSize temp2 ;
30963 PyObject * obj0 = 0 ;
30964 PyObject * obj1 = 0 ;
30965 char * kwnames[] = {
30966 (char *) "self",(char *) "size", NULL
30967 };
30968
30969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30971 if (!SWIG_IsOK(res1)) {
30972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30973 }
30974 arg1 = reinterpret_cast< wxWindow * >(argp1);
30975 {
30976 arg2 = &temp2;
30977 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30978 }
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 (arg1)->SetSize((wxSize const &)*arg2);
30982 wxPyEndAllowThreads(__tstate);
30983 if (PyErr_Occurred()) SWIG_fail;
30984 }
30985 resultobj = SWIG_Py_Void();
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj = 0;
30994 wxWindow *arg1 = (wxWindow *) 0 ;
30995 int arg2 ;
30996 int arg3 ;
30997 int arg4 ;
30998 int arg5 ;
30999 int arg6 = (int) wxSIZE_AUTO ;
31000 void *argp1 = 0 ;
31001 int res1 = 0 ;
31002 int val2 ;
31003 int ecode2 = 0 ;
31004 int val3 ;
31005 int ecode3 = 0 ;
31006 int val4 ;
31007 int ecode4 = 0 ;
31008 int val5 ;
31009 int ecode5 = 0 ;
31010 int val6 ;
31011 int ecode6 = 0 ;
31012 PyObject * obj0 = 0 ;
31013 PyObject * obj1 = 0 ;
31014 PyObject * obj2 = 0 ;
31015 PyObject * obj3 = 0 ;
31016 PyObject * obj4 = 0 ;
31017 PyObject * obj5 = 0 ;
31018 char * kwnames[] = {
31019 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31020 };
31021
31022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31024 if (!SWIG_IsOK(res1)) {
31025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31026 }
31027 arg1 = reinterpret_cast< wxWindow * >(argp1);
31028 ecode2 = SWIG_AsVal_int(obj1, &val2);
31029 if (!SWIG_IsOK(ecode2)) {
31030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31031 }
31032 arg2 = static_cast< int >(val2);
31033 ecode3 = SWIG_AsVal_int(obj2, &val3);
31034 if (!SWIG_IsOK(ecode3)) {
31035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31036 }
31037 arg3 = static_cast< int >(val3);
31038 ecode4 = SWIG_AsVal_int(obj3, &val4);
31039 if (!SWIG_IsOK(ecode4)) {
31040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31041 }
31042 arg4 = static_cast< int >(val4);
31043 ecode5 = SWIG_AsVal_int(obj4, &val5);
31044 if (!SWIG_IsOK(ecode5)) {
31045 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31046 }
31047 arg5 = static_cast< int >(val5);
31048 if (obj5) {
31049 ecode6 = SWIG_AsVal_int(obj5, &val6);
31050 if (!SWIG_IsOK(ecode6)) {
31051 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31052 }
31053 arg6 = static_cast< int >(val6);
31054 }
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 resultobj = SWIG_Py_Void();
31062 return resultobj;
31063 fail:
31064 return NULL;
31065 }
31066
31067
31068 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31069 PyObject *resultobj = 0;
31070 wxWindow *arg1 = (wxWindow *) 0 ;
31071 wxRect *arg2 = 0 ;
31072 int arg3 = (int) wxSIZE_AUTO ;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 wxRect temp2 ;
31076 int val3 ;
31077 int ecode3 = 0 ;
31078 PyObject * obj0 = 0 ;
31079 PyObject * obj1 = 0 ;
31080 PyObject * obj2 = 0 ;
31081 char * kwnames[] = {
31082 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31083 };
31084
31085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31087 if (!SWIG_IsOK(res1)) {
31088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31089 }
31090 arg1 = reinterpret_cast< wxWindow * >(argp1);
31091 {
31092 arg2 = &temp2;
31093 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31094 }
31095 if (obj2) {
31096 ecode3 = SWIG_AsVal_int(obj2, &val3);
31097 if (!SWIG_IsOK(ecode3)) {
31098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31099 }
31100 arg3 = static_cast< int >(val3);
31101 }
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31105 wxPyEndAllowThreads(__tstate);
31106 if (PyErr_Occurred()) SWIG_fail;
31107 }
31108 resultobj = SWIG_Py_Void();
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj = 0;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 int arg2 ;
31119 int arg3 ;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 int val2 ;
31123 int ecode2 = 0 ;
31124 int val3 ;
31125 int ecode3 = 0 ;
31126 PyObject * obj0 = 0 ;
31127 PyObject * obj1 = 0 ;
31128 PyObject * obj2 = 0 ;
31129 char * kwnames[] = {
31130 (char *) "self",(char *) "width",(char *) "height", NULL
31131 };
31132
31133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31135 if (!SWIG_IsOK(res1)) {
31136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31137 }
31138 arg1 = reinterpret_cast< wxWindow * >(argp1);
31139 ecode2 = SWIG_AsVal_int(obj1, &val2);
31140 if (!SWIG_IsOK(ecode2)) {
31141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31142 }
31143 arg2 = static_cast< int >(val2);
31144 ecode3 = SWIG_AsVal_int(obj2, &val3);
31145 if (!SWIG_IsOK(ecode3)) {
31146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31147 }
31148 arg3 = static_cast< int >(val3);
31149 {
31150 PyThreadState* __tstate = wxPyBeginAllowThreads();
31151 (arg1)->SetSize(arg2,arg3);
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 resultobj = SWIG_Py_Void();
31156 return resultobj;
31157 fail:
31158 return NULL;
31159 }
31160
31161
31162 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31163 PyObject *resultobj = 0;
31164 wxWindow *arg1 = (wxWindow *) 0 ;
31165 wxPoint *arg2 = 0 ;
31166 int arg3 = (int) wxSIZE_USE_EXISTING ;
31167 void *argp1 = 0 ;
31168 int res1 = 0 ;
31169 wxPoint temp2 ;
31170 int val3 ;
31171 int ecode3 = 0 ;
31172 PyObject * obj0 = 0 ;
31173 PyObject * obj1 = 0 ;
31174 PyObject * obj2 = 0 ;
31175 char * kwnames[] = {
31176 (char *) "self",(char *) "pt",(char *) "flags", NULL
31177 };
31178
31179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31181 if (!SWIG_IsOK(res1)) {
31182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31183 }
31184 arg1 = reinterpret_cast< wxWindow * >(argp1);
31185 {
31186 arg2 = &temp2;
31187 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31188 }
31189 if (obj2) {
31190 ecode3 = SWIG_AsVal_int(obj2, &val3);
31191 if (!SWIG_IsOK(ecode3)) {
31192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31193 }
31194 arg3 = static_cast< int >(val3);
31195 }
31196 {
31197 PyThreadState* __tstate = wxPyBeginAllowThreads();
31198 (arg1)->Move((wxPoint const &)*arg2,arg3);
31199 wxPyEndAllowThreads(__tstate);
31200 if (PyErr_Occurred()) SWIG_fail;
31201 }
31202 resultobj = SWIG_Py_Void();
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj = 0;
31211 wxWindow *arg1 = (wxWindow *) 0 ;
31212 int arg2 ;
31213 int arg3 ;
31214 int arg4 = (int) wxSIZE_USE_EXISTING ;
31215 void *argp1 = 0 ;
31216 int res1 = 0 ;
31217 int val2 ;
31218 int ecode2 = 0 ;
31219 int val3 ;
31220 int ecode3 = 0 ;
31221 int val4 ;
31222 int ecode4 = 0 ;
31223 PyObject * obj0 = 0 ;
31224 PyObject * obj1 = 0 ;
31225 PyObject * obj2 = 0 ;
31226 PyObject * obj3 = 0 ;
31227 char * kwnames[] = {
31228 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31229 };
31230
31231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31233 if (!SWIG_IsOK(res1)) {
31234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31235 }
31236 arg1 = reinterpret_cast< wxWindow * >(argp1);
31237 ecode2 = SWIG_AsVal_int(obj1, &val2);
31238 if (!SWIG_IsOK(ecode2)) {
31239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31240 }
31241 arg2 = static_cast< int >(val2);
31242 ecode3 = SWIG_AsVal_int(obj2, &val3);
31243 if (!SWIG_IsOK(ecode3)) {
31244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31245 }
31246 arg3 = static_cast< int >(val3);
31247 if (obj3) {
31248 ecode4 = SWIG_AsVal_int(obj3, &val4);
31249 if (!SWIG_IsOK(ecode4)) {
31250 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31251 }
31252 arg4 = static_cast< int >(val4);
31253 }
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 (arg1)->Move(arg2,arg3,arg4);
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 resultobj = SWIG_Py_Void();
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31268 PyObject *resultobj = 0;
31269 wxWindow *arg1 = (wxWindow *) 0 ;
31270 wxSize const &arg2_defvalue = wxDefaultSize ;
31271 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31272 void *argp1 = 0 ;
31273 int res1 = 0 ;
31274 wxSize temp2 ;
31275 PyObject * obj0 = 0 ;
31276 PyObject * obj1 = 0 ;
31277 char * kwnames[] = {
31278 (char *) "self",(char *) "size", NULL
31279 };
31280
31281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31283 if (!SWIG_IsOK(res1)) {
31284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31285 }
31286 arg1 = reinterpret_cast< wxWindow * >(argp1);
31287 if (obj1) {
31288 {
31289 arg2 = &temp2;
31290 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31291 }
31292 }
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 resultobj = SWIG_Py_Void();
31300 return resultobj;
31301 fail:
31302 return NULL;
31303 }
31304
31305
31306 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31307 PyObject *resultobj = 0;
31308 wxWindow *arg1 = (wxWindow *) 0 ;
31309 void *argp1 = 0 ;
31310 int res1 = 0 ;
31311 PyObject *swig_obj[1] ;
31312
31313 if (!args) SWIG_fail;
31314 swig_obj[0] = args;
31315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31316 if (!SWIG_IsOK(res1)) {
31317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31318 }
31319 arg1 = reinterpret_cast< wxWindow * >(argp1);
31320 {
31321 PyThreadState* __tstate = wxPyBeginAllowThreads();
31322 (arg1)->Raise();
31323 wxPyEndAllowThreads(__tstate);
31324 if (PyErr_Occurred()) SWIG_fail;
31325 }
31326 resultobj = SWIG_Py_Void();
31327 return resultobj;
31328 fail:
31329 return NULL;
31330 }
31331
31332
31333 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31334 PyObject *resultobj = 0;
31335 wxWindow *arg1 = (wxWindow *) 0 ;
31336 void *argp1 = 0 ;
31337 int res1 = 0 ;
31338 PyObject *swig_obj[1] ;
31339
31340 if (!args) SWIG_fail;
31341 swig_obj[0] = args;
31342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31343 if (!SWIG_IsOK(res1)) {
31344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31345 }
31346 arg1 = reinterpret_cast< wxWindow * >(argp1);
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 (arg1)->Lower();
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 resultobj = SWIG_Py_Void();
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31361 PyObject *resultobj = 0;
31362 wxWindow *arg1 = (wxWindow *) 0 ;
31363 wxSize *arg2 = 0 ;
31364 void *argp1 = 0 ;
31365 int res1 = 0 ;
31366 wxSize temp2 ;
31367 PyObject * obj0 = 0 ;
31368 PyObject * obj1 = 0 ;
31369 char * kwnames[] = {
31370 (char *) "self",(char *) "size", NULL
31371 };
31372
31373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31375 if (!SWIG_IsOK(res1)) {
31376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31377 }
31378 arg1 = reinterpret_cast< wxWindow * >(argp1);
31379 {
31380 arg2 = &temp2;
31381 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31382 }
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 (arg1)->SetClientSize((wxSize const &)*arg2);
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 resultobj = SWIG_Py_Void();
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31397 PyObject *resultobj = 0;
31398 wxWindow *arg1 = (wxWindow *) 0 ;
31399 int arg2 ;
31400 int arg3 ;
31401 void *argp1 = 0 ;
31402 int res1 = 0 ;
31403 int val2 ;
31404 int ecode2 = 0 ;
31405 int val3 ;
31406 int ecode3 = 0 ;
31407 PyObject * obj0 = 0 ;
31408 PyObject * obj1 = 0 ;
31409 PyObject * obj2 = 0 ;
31410 char * kwnames[] = {
31411 (char *) "self",(char *) "width",(char *) "height", NULL
31412 };
31413
31414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31416 if (!SWIG_IsOK(res1)) {
31417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31418 }
31419 arg1 = reinterpret_cast< wxWindow * >(argp1);
31420 ecode2 = SWIG_AsVal_int(obj1, &val2);
31421 if (!SWIG_IsOK(ecode2)) {
31422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31423 }
31424 arg2 = static_cast< int >(val2);
31425 ecode3 = SWIG_AsVal_int(obj2, &val3);
31426 if (!SWIG_IsOK(ecode3)) {
31427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31428 }
31429 arg3 = static_cast< int >(val3);
31430 {
31431 PyThreadState* __tstate = wxPyBeginAllowThreads();
31432 (arg1)->SetClientSize(arg2,arg3);
31433 wxPyEndAllowThreads(__tstate);
31434 if (PyErr_Occurred()) SWIG_fail;
31435 }
31436 resultobj = SWIG_Py_Void();
31437 return resultobj;
31438 fail:
31439 return NULL;
31440 }
31441
31442
31443 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31444 PyObject *resultobj = 0;
31445 wxWindow *arg1 = (wxWindow *) 0 ;
31446 wxRect *arg2 = 0 ;
31447 void *argp1 = 0 ;
31448 int res1 = 0 ;
31449 wxRect temp2 ;
31450 PyObject * obj0 = 0 ;
31451 PyObject * obj1 = 0 ;
31452 char * kwnames[] = {
31453 (char *) "self",(char *) "rect", NULL
31454 };
31455
31456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31458 if (!SWIG_IsOK(res1)) {
31459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31460 }
31461 arg1 = reinterpret_cast< wxWindow * >(argp1);
31462 {
31463 arg2 = &temp2;
31464 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31465 }
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 (arg1)->SetClientSize((wxRect const &)*arg2);
31469 wxPyEndAllowThreads(__tstate);
31470 if (PyErr_Occurred()) SWIG_fail;
31471 }
31472 resultobj = SWIG_Py_Void();
31473 return resultobj;
31474 fail:
31475 return NULL;
31476 }
31477
31478
31479 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31480 PyObject *resultobj = 0;
31481 wxWindow *arg1 = (wxWindow *) 0 ;
31482 wxPoint result;
31483 void *argp1 = 0 ;
31484 int res1 = 0 ;
31485 PyObject *swig_obj[1] ;
31486
31487 if (!args) SWIG_fail;
31488 swig_obj[0] = args;
31489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31490 if (!SWIG_IsOK(res1)) {
31491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31492 }
31493 arg1 = reinterpret_cast< wxWindow * >(argp1);
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 result = ((wxWindow const *)arg1)->GetPosition();
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31501 return resultobj;
31502 fail:
31503 return NULL;
31504 }
31505
31506
31507 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31508 PyObject *resultobj = 0;
31509 wxWindow *arg1 = (wxWindow *) 0 ;
31510 int *arg2 = (int *) 0 ;
31511 int *arg3 = (int *) 0 ;
31512 void *argp1 = 0 ;
31513 int res1 = 0 ;
31514 int temp2 ;
31515 int res2 = SWIG_TMPOBJ ;
31516 int temp3 ;
31517 int res3 = SWIG_TMPOBJ ;
31518 PyObject *swig_obj[1] ;
31519
31520 arg2 = &temp2;
31521 arg3 = &temp3;
31522 if (!args) SWIG_fail;
31523 swig_obj[0] = args;
31524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31525 if (!SWIG_IsOK(res1)) {
31526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31527 }
31528 arg1 = reinterpret_cast< wxWindow * >(argp1);
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 resultobj = SWIG_Py_Void();
31536 if (SWIG_IsTmpObj(res2)) {
31537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31538 } else {
31539 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31541 }
31542 if (SWIG_IsTmpObj(res3)) {
31543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31544 } else {
31545 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31547 }
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 PyObject *resultobj = 0;
31556 wxWindow *arg1 = (wxWindow *) 0 ;
31557 wxPoint result;
31558 void *argp1 = 0 ;
31559 int res1 = 0 ;
31560 PyObject *swig_obj[1] ;
31561
31562 if (!args) SWIG_fail;
31563 swig_obj[0] = args;
31564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31565 if (!SWIG_IsOK(res1)) {
31566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31567 }
31568 arg1 = reinterpret_cast< wxWindow * >(argp1);
31569 {
31570 PyThreadState* __tstate = wxPyBeginAllowThreads();
31571 result = ((wxWindow const *)arg1)->GetScreenPosition();
31572 wxPyEndAllowThreads(__tstate);
31573 if (PyErr_Occurred()) SWIG_fail;
31574 }
31575 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31576 return resultobj;
31577 fail:
31578 return NULL;
31579 }
31580
31581
31582 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31583 PyObject *resultobj = 0;
31584 wxWindow *arg1 = (wxWindow *) 0 ;
31585 int *arg2 = (int *) 0 ;
31586 int *arg3 = (int *) 0 ;
31587 void *argp1 = 0 ;
31588 int res1 = 0 ;
31589 int temp2 ;
31590 int res2 = SWIG_TMPOBJ ;
31591 int temp3 ;
31592 int res3 = SWIG_TMPOBJ ;
31593 PyObject *swig_obj[1] ;
31594
31595 arg2 = &temp2;
31596 arg3 = &temp3;
31597 if (!args) SWIG_fail;
31598 swig_obj[0] = args;
31599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31600 if (!SWIG_IsOK(res1)) {
31601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31602 }
31603 arg1 = reinterpret_cast< wxWindow * >(argp1);
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31607 wxPyEndAllowThreads(__tstate);
31608 if (PyErr_Occurred()) SWIG_fail;
31609 }
31610 resultobj = SWIG_Py_Void();
31611 if (SWIG_IsTmpObj(res2)) {
31612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31613 } else {
31614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31616 }
31617 if (SWIG_IsTmpObj(res3)) {
31618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31619 } else {
31620 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31622 }
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31630 PyObject *resultobj = 0;
31631 wxWindow *arg1 = (wxWindow *) 0 ;
31632 wxRect result;
31633 void *argp1 = 0 ;
31634 int res1 = 0 ;
31635 PyObject *swig_obj[1] ;
31636
31637 if (!args) SWIG_fail;
31638 swig_obj[0] = args;
31639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31640 if (!SWIG_IsOK(res1)) {
31641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31642 }
31643 arg1 = reinterpret_cast< wxWindow * >(argp1);
31644 {
31645 PyThreadState* __tstate = wxPyBeginAllowThreads();
31646 result = ((wxWindow const *)arg1)->GetScreenRect();
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31651 return resultobj;
31652 fail:
31653 return NULL;
31654 }
31655
31656
31657 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31658 PyObject *resultobj = 0;
31659 wxWindow *arg1 = (wxWindow *) 0 ;
31660 wxSize result;
31661 void *argp1 = 0 ;
31662 int res1 = 0 ;
31663 PyObject *swig_obj[1] ;
31664
31665 if (!args) SWIG_fail;
31666 swig_obj[0] = args;
31667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31668 if (!SWIG_IsOK(res1)) {
31669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31670 }
31671 arg1 = reinterpret_cast< wxWindow * >(argp1);
31672 {
31673 PyThreadState* __tstate = wxPyBeginAllowThreads();
31674 result = ((wxWindow const *)arg1)->GetSize();
31675 wxPyEndAllowThreads(__tstate);
31676 if (PyErr_Occurred()) SWIG_fail;
31677 }
31678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31679 return resultobj;
31680 fail:
31681 return NULL;
31682 }
31683
31684
31685 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31686 PyObject *resultobj = 0;
31687 wxWindow *arg1 = (wxWindow *) 0 ;
31688 int *arg2 = (int *) 0 ;
31689 int *arg3 = (int *) 0 ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 int temp2 ;
31693 int res2 = SWIG_TMPOBJ ;
31694 int temp3 ;
31695 int res3 = SWIG_TMPOBJ ;
31696 PyObject *swig_obj[1] ;
31697
31698 arg2 = &temp2;
31699 arg3 = &temp3;
31700 if (!args) SWIG_fail;
31701 swig_obj[0] = args;
31702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31705 }
31706 arg1 = reinterpret_cast< wxWindow * >(argp1);
31707 {
31708 PyThreadState* __tstate = wxPyBeginAllowThreads();
31709 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31710 wxPyEndAllowThreads(__tstate);
31711 if (PyErr_Occurred()) SWIG_fail;
31712 }
31713 resultobj = SWIG_Py_Void();
31714 if (SWIG_IsTmpObj(res2)) {
31715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31716 } else {
31717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31719 }
31720 if (SWIG_IsTmpObj(res3)) {
31721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31722 } else {
31723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31725 }
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 wxRect result;
31736 void *argp1 = 0 ;
31737 int res1 = 0 ;
31738 PyObject *swig_obj[1] ;
31739
31740 if (!args) SWIG_fail;
31741 swig_obj[0] = args;
31742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31743 if (!SWIG_IsOK(res1)) {
31744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31745 }
31746 arg1 = reinterpret_cast< wxWindow * >(argp1);
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = ((wxWindow const *)arg1)->GetRect();
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31754 return resultobj;
31755 fail:
31756 return NULL;
31757 }
31758
31759
31760 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 PyObject *resultobj = 0;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 wxSize result;
31764 void *argp1 = 0 ;
31765 int res1 = 0 ;
31766 PyObject *swig_obj[1] ;
31767
31768 if (!args) SWIG_fail;
31769 swig_obj[0] = args;
31770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31771 if (!SWIG_IsOK(res1)) {
31772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31773 }
31774 arg1 = reinterpret_cast< wxWindow * >(argp1);
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 result = ((wxWindow const *)arg1)->GetClientSize();
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 int *arg2 = (int *) 0 ;
31792 int *arg3 = (int *) 0 ;
31793 void *argp1 = 0 ;
31794 int res1 = 0 ;
31795 int temp2 ;
31796 int res2 = SWIG_TMPOBJ ;
31797 int temp3 ;
31798 int res3 = SWIG_TMPOBJ ;
31799 PyObject *swig_obj[1] ;
31800
31801 arg2 = &temp2;
31802 arg3 = &temp3;
31803 if (!args) SWIG_fail;
31804 swig_obj[0] = args;
31805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31808 }
31809 arg1 = reinterpret_cast< wxWindow * >(argp1);
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_Py_Void();
31817 if (SWIG_IsTmpObj(res2)) {
31818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31819 } else {
31820 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31822 }
31823 if (SWIG_IsTmpObj(res3)) {
31824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31825 } else {
31826 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31828 }
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 PyObject *resultobj = 0;
31837 wxWindow *arg1 = (wxWindow *) 0 ;
31838 wxPoint result;
31839 void *argp1 = 0 ;
31840 int res1 = 0 ;
31841 PyObject *swig_obj[1] ;
31842
31843 if (!args) SWIG_fail;
31844 swig_obj[0] = args;
31845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31846 if (!SWIG_IsOK(res1)) {
31847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31848 }
31849 arg1 = reinterpret_cast< wxWindow * >(argp1);
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31864 PyObject *resultobj = 0;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 wxRect result;
31867 void *argp1 = 0 ;
31868 int res1 = 0 ;
31869 PyObject *swig_obj[1] ;
31870
31871 if (!args) SWIG_fail;
31872 swig_obj[0] = args;
31873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31874 if (!SWIG_IsOK(res1)) {
31875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31876 }
31877 arg1 = reinterpret_cast< wxWindow * >(argp1);
31878 {
31879 PyThreadState* __tstate = wxPyBeginAllowThreads();
31880 result = ((wxWindow const *)arg1)->GetClientRect();
31881 wxPyEndAllowThreads(__tstate);
31882 if (PyErr_Occurred()) SWIG_fail;
31883 }
31884 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31885 return resultobj;
31886 fail:
31887 return NULL;
31888 }
31889
31890
31891 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31892 PyObject *resultobj = 0;
31893 wxWindow *arg1 = (wxWindow *) 0 ;
31894 wxSize result;
31895 void *argp1 = 0 ;
31896 int res1 = 0 ;
31897 PyObject *swig_obj[1] ;
31898
31899 if (!args) SWIG_fail;
31900 swig_obj[0] = args;
31901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31902 if (!SWIG_IsOK(res1)) {
31903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31904 }
31905 arg1 = reinterpret_cast< wxWindow * >(argp1);
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 result = ((wxWindow const *)arg1)->GetBestSize();
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31920 PyObject *resultobj = 0;
31921 wxWindow *arg1 = (wxWindow *) 0 ;
31922 int *arg2 = (int *) 0 ;
31923 int *arg3 = (int *) 0 ;
31924 void *argp1 = 0 ;
31925 int res1 = 0 ;
31926 int temp2 ;
31927 int res2 = SWIG_TMPOBJ ;
31928 int temp3 ;
31929 int res3 = SWIG_TMPOBJ ;
31930 PyObject *swig_obj[1] ;
31931
31932 arg2 = &temp2;
31933 arg3 = &temp3;
31934 if (!args) SWIG_fail;
31935 swig_obj[0] = args;
31936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31937 if (!SWIG_IsOK(res1)) {
31938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31939 }
31940 arg1 = reinterpret_cast< wxWindow * >(argp1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_Py_Void();
31948 if (SWIG_IsTmpObj(res2)) {
31949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31950 } else {
31951 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31953 }
31954 if (SWIG_IsTmpObj(res3)) {
31955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31956 } else {
31957 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31959 }
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967 PyObject *resultobj = 0;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971 PyObject *swig_obj[1] ;
31972
31973 if (!args) SWIG_fail;
31974 swig_obj[0] = args;
31975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31976 if (!SWIG_IsOK(res1)) {
31977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31978 }
31979 arg1 = reinterpret_cast< wxWindow * >(argp1);
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 (arg1)->InvalidateBestSize();
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 resultobj = SWIG_Py_Void();
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31994 PyObject *resultobj = 0;
31995 wxWindow *arg1 = (wxWindow *) 0 ;
31996 wxSize *arg2 = 0 ;
31997 void *argp1 = 0 ;
31998 int res1 = 0 ;
31999 wxSize temp2 ;
32000 PyObject * obj0 = 0 ;
32001 PyObject * obj1 = 0 ;
32002 char * kwnames[] = {
32003 (char *) "self",(char *) "size", NULL
32004 };
32005
32006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32008 if (!SWIG_IsOK(res1)) {
32009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32010 }
32011 arg1 = reinterpret_cast< wxWindow * >(argp1);
32012 {
32013 arg2 = &temp2;
32014 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32015 }
32016 {
32017 PyThreadState* __tstate = wxPyBeginAllowThreads();
32018 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32019 wxPyEndAllowThreads(__tstate);
32020 if (PyErr_Occurred()) SWIG_fail;
32021 }
32022 resultobj = SWIG_Py_Void();
32023 return resultobj;
32024 fail:
32025 return NULL;
32026 }
32027
32028
32029 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32030 PyObject *resultobj = 0;
32031 wxWindow *arg1 = (wxWindow *) 0 ;
32032 wxSize result;
32033 void *argp1 = 0 ;
32034 int res1 = 0 ;
32035 PyObject *swig_obj[1] ;
32036
32037 if (!args) SWIG_fail;
32038 swig_obj[0] = args;
32039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32040 if (!SWIG_IsOK(res1)) {
32041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32042 }
32043 arg1 = reinterpret_cast< wxWindow * >(argp1);
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32058 PyObject *resultobj = 0;
32059 wxWindow *arg1 = (wxWindow *) 0 ;
32060 wxSize result;
32061 void *argp1 = 0 ;
32062 int res1 = 0 ;
32063 PyObject *swig_obj[1] ;
32064
32065 if (!args) SWIG_fail;
32066 swig_obj[0] = args;
32067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32068 if (!SWIG_IsOK(res1)) {
32069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32070 }
32071 arg1 = reinterpret_cast< wxWindow * >(argp1);
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32086 PyObject *resultobj = 0;
32087 wxWindow *arg1 = (wxWindow *) 0 ;
32088 int arg2 = (int) wxBOTH ;
32089 void *argp1 = 0 ;
32090 int res1 = 0 ;
32091 int val2 ;
32092 int ecode2 = 0 ;
32093 PyObject * obj0 = 0 ;
32094 PyObject * obj1 = 0 ;
32095 char * kwnames[] = {
32096 (char *) "self",(char *) "direction", NULL
32097 };
32098
32099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32101 if (!SWIG_IsOK(res1)) {
32102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32103 }
32104 arg1 = reinterpret_cast< wxWindow * >(argp1);
32105 if (obj1) {
32106 ecode2 = SWIG_AsVal_int(obj1, &val2);
32107 if (!SWIG_IsOK(ecode2)) {
32108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32109 }
32110 arg2 = static_cast< int >(val2);
32111 }
32112 {
32113 PyThreadState* __tstate = wxPyBeginAllowThreads();
32114 (arg1)->Center(arg2);
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 resultobj = SWIG_Py_Void();
32119 return resultobj;
32120 fail:
32121 return NULL;
32122 }
32123
32124
32125 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32126 PyObject *resultobj = 0;
32127 wxWindow *arg1 = (wxWindow *) 0 ;
32128 int arg2 = (int) wxBOTH ;
32129 void *argp1 = 0 ;
32130 int res1 = 0 ;
32131 int val2 ;
32132 int ecode2 = 0 ;
32133 PyObject * obj0 = 0 ;
32134 PyObject * obj1 = 0 ;
32135 char * kwnames[] = {
32136 (char *) "self",(char *) "dir", NULL
32137 };
32138
32139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32141 if (!SWIG_IsOK(res1)) {
32142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32143 }
32144 arg1 = reinterpret_cast< wxWindow * >(argp1);
32145 if (obj1) {
32146 ecode2 = SWIG_AsVal_int(obj1, &val2);
32147 if (!SWIG_IsOK(ecode2)) {
32148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32149 }
32150 arg2 = static_cast< int >(val2);
32151 }
32152 {
32153 PyThreadState* __tstate = wxPyBeginAllowThreads();
32154 (arg1)->CenterOnParent(arg2);
32155 wxPyEndAllowThreads(__tstate);
32156 if (PyErr_Occurred()) SWIG_fail;
32157 }
32158 resultobj = SWIG_Py_Void();
32159 return resultobj;
32160 fail:
32161 return NULL;
32162 }
32163
32164
32165 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32166 PyObject *resultobj = 0;
32167 wxWindow *arg1 = (wxWindow *) 0 ;
32168 void *argp1 = 0 ;
32169 int res1 = 0 ;
32170 PyObject *swig_obj[1] ;
32171
32172 if (!args) SWIG_fail;
32173 swig_obj[0] = args;
32174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32175 if (!SWIG_IsOK(res1)) {
32176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32177 }
32178 arg1 = reinterpret_cast< wxWindow * >(argp1);
32179 {
32180 PyThreadState* __tstate = wxPyBeginAllowThreads();
32181 (arg1)->Fit();
32182 wxPyEndAllowThreads(__tstate);
32183 if (PyErr_Occurred()) SWIG_fail;
32184 }
32185 resultobj = SWIG_Py_Void();
32186 return resultobj;
32187 fail:
32188 return NULL;
32189 }
32190
32191
32192 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32193 PyObject *resultobj = 0;
32194 wxWindow *arg1 = (wxWindow *) 0 ;
32195 void *argp1 = 0 ;
32196 int res1 = 0 ;
32197 PyObject *swig_obj[1] ;
32198
32199 if (!args) SWIG_fail;
32200 swig_obj[0] = args;
32201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32202 if (!SWIG_IsOK(res1)) {
32203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32204 }
32205 arg1 = reinterpret_cast< wxWindow * >(argp1);
32206 {
32207 PyThreadState* __tstate = wxPyBeginAllowThreads();
32208 (arg1)->FitInside();
32209 wxPyEndAllowThreads(__tstate);
32210 if (PyErr_Occurred()) SWIG_fail;
32211 }
32212 resultobj = SWIG_Py_Void();
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32220 PyObject *resultobj = 0;
32221 wxWindow *arg1 = (wxWindow *) 0 ;
32222 int arg2 ;
32223 int arg3 ;
32224 int arg4 = (int) -1 ;
32225 int arg5 = (int) -1 ;
32226 int arg6 = (int) -1 ;
32227 int arg7 = (int) -1 ;
32228 void *argp1 = 0 ;
32229 int res1 = 0 ;
32230 int val2 ;
32231 int ecode2 = 0 ;
32232 int val3 ;
32233 int ecode3 = 0 ;
32234 int val4 ;
32235 int ecode4 = 0 ;
32236 int val5 ;
32237 int ecode5 = 0 ;
32238 int val6 ;
32239 int ecode6 = 0 ;
32240 int val7 ;
32241 int ecode7 = 0 ;
32242 PyObject * obj0 = 0 ;
32243 PyObject * obj1 = 0 ;
32244 PyObject * obj2 = 0 ;
32245 PyObject * obj3 = 0 ;
32246 PyObject * obj4 = 0 ;
32247 PyObject * obj5 = 0 ;
32248 PyObject * obj6 = 0 ;
32249 char * kwnames[] = {
32250 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32251 };
32252
32253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32255 if (!SWIG_IsOK(res1)) {
32256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32257 }
32258 arg1 = reinterpret_cast< wxWindow * >(argp1);
32259 ecode2 = SWIG_AsVal_int(obj1, &val2);
32260 if (!SWIG_IsOK(ecode2)) {
32261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32262 }
32263 arg2 = static_cast< int >(val2);
32264 ecode3 = SWIG_AsVal_int(obj2, &val3);
32265 if (!SWIG_IsOK(ecode3)) {
32266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32267 }
32268 arg3 = static_cast< int >(val3);
32269 if (obj3) {
32270 ecode4 = SWIG_AsVal_int(obj3, &val4);
32271 if (!SWIG_IsOK(ecode4)) {
32272 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32273 }
32274 arg4 = static_cast< int >(val4);
32275 }
32276 if (obj4) {
32277 ecode5 = SWIG_AsVal_int(obj4, &val5);
32278 if (!SWIG_IsOK(ecode5)) {
32279 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32280 }
32281 arg5 = static_cast< int >(val5);
32282 }
32283 if (obj5) {
32284 ecode6 = SWIG_AsVal_int(obj5, &val6);
32285 if (!SWIG_IsOK(ecode6)) {
32286 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32287 }
32288 arg6 = static_cast< int >(val6);
32289 }
32290 if (obj6) {
32291 ecode7 = SWIG_AsVal_int(obj6, &val7);
32292 if (!SWIG_IsOK(ecode7)) {
32293 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32294 }
32295 arg7 = static_cast< int >(val7);
32296 }
32297 {
32298 PyThreadState* __tstate = wxPyBeginAllowThreads();
32299 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32300 wxPyEndAllowThreads(__tstate);
32301 if (PyErr_Occurred()) SWIG_fail;
32302 }
32303 resultobj = SWIG_Py_Void();
32304 return resultobj;
32305 fail:
32306 return NULL;
32307 }
32308
32309
32310 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32311 PyObject *resultobj = 0;
32312 wxWindow *arg1 = (wxWindow *) 0 ;
32313 wxSize *arg2 = 0 ;
32314 wxSize const &arg3_defvalue = wxDefaultSize ;
32315 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32316 wxSize const &arg4_defvalue = wxDefaultSize ;
32317 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32318 void *argp1 = 0 ;
32319 int res1 = 0 ;
32320 wxSize temp2 ;
32321 wxSize temp3 ;
32322 wxSize temp4 ;
32323 PyObject * obj0 = 0 ;
32324 PyObject * obj1 = 0 ;
32325 PyObject * obj2 = 0 ;
32326 PyObject * obj3 = 0 ;
32327 char * kwnames[] = {
32328 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32329 };
32330
32331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32335 }
32336 arg1 = reinterpret_cast< wxWindow * >(argp1);
32337 {
32338 arg2 = &temp2;
32339 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32340 }
32341 if (obj2) {
32342 {
32343 arg3 = &temp3;
32344 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32345 }
32346 }
32347 if (obj3) {
32348 {
32349 arg4 = &temp4;
32350 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32351 }
32352 }
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 resultobj = SWIG_Py_Void();
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32367 PyObject *resultobj = 0;
32368 wxWindow *arg1 = (wxWindow *) 0 ;
32369 int arg2 ;
32370 int arg3 ;
32371 int arg4 = (int) -1 ;
32372 int arg5 = (int) -1 ;
32373 void *argp1 = 0 ;
32374 int res1 = 0 ;
32375 int val2 ;
32376 int ecode2 = 0 ;
32377 int val3 ;
32378 int ecode3 = 0 ;
32379 int val4 ;
32380 int ecode4 = 0 ;
32381 int val5 ;
32382 int ecode5 = 0 ;
32383 PyObject * obj0 = 0 ;
32384 PyObject * obj1 = 0 ;
32385 PyObject * obj2 = 0 ;
32386 PyObject * obj3 = 0 ;
32387 PyObject * obj4 = 0 ;
32388 char * kwnames[] = {
32389 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32390 };
32391
32392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32394 if (!SWIG_IsOK(res1)) {
32395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32396 }
32397 arg1 = reinterpret_cast< wxWindow * >(argp1);
32398 ecode2 = SWIG_AsVal_int(obj1, &val2);
32399 if (!SWIG_IsOK(ecode2)) {
32400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32401 }
32402 arg2 = static_cast< int >(val2);
32403 ecode3 = SWIG_AsVal_int(obj2, &val3);
32404 if (!SWIG_IsOK(ecode3)) {
32405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32406 }
32407 arg3 = static_cast< int >(val3);
32408 if (obj3) {
32409 ecode4 = SWIG_AsVal_int(obj3, &val4);
32410 if (!SWIG_IsOK(ecode4)) {
32411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32412 }
32413 arg4 = static_cast< int >(val4);
32414 }
32415 if (obj4) {
32416 ecode5 = SWIG_AsVal_int(obj4, &val5);
32417 if (!SWIG_IsOK(ecode5)) {
32418 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32419 }
32420 arg5 = static_cast< int >(val5);
32421 }
32422 {
32423 PyThreadState* __tstate = wxPyBeginAllowThreads();
32424 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32425 wxPyEndAllowThreads(__tstate);
32426 if (PyErr_Occurred()) SWIG_fail;
32427 }
32428 resultobj = SWIG_Py_Void();
32429 return resultobj;
32430 fail:
32431 return NULL;
32432 }
32433
32434
32435 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32436 PyObject *resultobj = 0;
32437 wxWindow *arg1 = (wxWindow *) 0 ;
32438 wxSize *arg2 = 0 ;
32439 wxSize const &arg3_defvalue = wxDefaultSize ;
32440 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32441 void *argp1 = 0 ;
32442 int res1 = 0 ;
32443 wxSize temp2 ;
32444 wxSize temp3 ;
32445 PyObject * obj0 = 0 ;
32446 PyObject * obj1 = 0 ;
32447 PyObject * obj2 = 0 ;
32448 char * kwnames[] = {
32449 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32450 };
32451
32452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32454 if (!SWIG_IsOK(res1)) {
32455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32456 }
32457 arg1 = reinterpret_cast< wxWindow * >(argp1);
32458 {
32459 arg2 = &temp2;
32460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32461 }
32462 if (obj2) {
32463 {
32464 arg3 = &temp3;
32465 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32466 }
32467 }
32468 {
32469 PyThreadState* __tstate = wxPyBeginAllowThreads();
32470 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32471 wxPyEndAllowThreads(__tstate);
32472 if (PyErr_Occurred()) SWIG_fail;
32473 }
32474 resultobj = SWIG_Py_Void();
32475 return resultobj;
32476 fail:
32477 return NULL;
32478 }
32479
32480
32481 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32482 PyObject *resultobj = 0;
32483 wxWindow *arg1 = (wxWindow *) 0 ;
32484 wxSize result;
32485 void *argp1 = 0 ;
32486 int res1 = 0 ;
32487 PyObject *swig_obj[1] ;
32488
32489 if (!args) SWIG_fail;
32490 swig_obj[0] = args;
32491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32494 }
32495 arg1 = reinterpret_cast< wxWindow * >(argp1);
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = ((wxWindow const *)arg1)->GetMaxSize();
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32503 return resultobj;
32504 fail:
32505 return NULL;
32506 }
32507
32508
32509 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32510 PyObject *resultobj = 0;
32511 wxWindow *arg1 = (wxWindow *) 0 ;
32512 wxSize result;
32513 void *argp1 = 0 ;
32514 int res1 = 0 ;
32515 PyObject *swig_obj[1] ;
32516
32517 if (!args) SWIG_fail;
32518 swig_obj[0] = args;
32519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32520 if (!SWIG_IsOK(res1)) {
32521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32522 }
32523 arg1 = reinterpret_cast< wxWindow * >(argp1);
32524 {
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 result = ((wxWindow const *)arg1)->GetMinSize();
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32538 PyObject *resultobj = 0;
32539 wxWindow *arg1 = (wxWindow *) 0 ;
32540 wxSize *arg2 = 0 ;
32541 void *argp1 = 0 ;
32542 int res1 = 0 ;
32543 wxSize temp2 ;
32544 PyObject * obj0 = 0 ;
32545 PyObject * obj1 = 0 ;
32546 char * kwnames[] = {
32547 (char *) "self",(char *) "minSize", NULL
32548 };
32549
32550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32552 if (!SWIG_IsOK(res1)) {
32553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32554 }
32555 arg1 = reinterpret_cast< wxWindow * >(argp1);
32556 {
32557 arg2 = &temp2;
32558 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32559 }
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 (arg1)->SetMinSize((wxSize const &)*arg2);
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 resultobj = SWIG_Py_Void();
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32574 PyObject *resultobj = 0;
32575 wxWindow *arg1 = (wxWindow *) 0 ;
32576 wxSize *arg2 = 0 ;
32577 void *argp1 = 0 ;
32578 int res1 = 0 ;
32579 wxSize temp2 ;
32580 PyObject * obj0 = 0 ;
32581 PyObject * obj1 = 0 ;
32582 char * kwnames[] = {
32583 (char *) "self",(char *) "maxSize", NULL
32584 };
32585
32586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32588 if (!SWIG_IsOK(res1)) {
32589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32590 }
32591 arg1 = reinterpret_cast< wxWindow * >(argp1);
32592 {
32593 arg2 = &temp2;
32594 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32595 }
32596 {
32597 PyThreadState* __tstate = wxPyBeginAllowThreads();
32598 (arg1)->SetMaxSize((wxSize const &)*arg2);
32599 wxPyEndAllowThreads(__tstate);
32600 if (PyErr_Occurred()) SWIG_fail;
32601 }
32602 resultobj = SWIG_Py_Void();
32603 return resultobj;
32604 fail:
32605 return NULL;
32606 }
32607
32608
32609 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32610 PyObject *resultobj = 0;
32611 wxWindow *arg1 = (wxWindow *) 0 ;
32612 int result;
32613 void *argp1 = 0 ;
32614 int res1 = 0 ;
32615 PyObject *swig_obj[1] ;
32616
32617 if (!args) SWIG_fail;
32618 swig_obj[0] = args;
32619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32620 if (!SWIG_IsOK(res1)) {
32621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32622 }
32623 arg1 = reinterpret_cast< wxWindow * >(argp1);
32624 {
32625 PyThreadState* __tstate = wxPyBeginAllowThreads();
32626 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32627 wxPyEndAllowThreads(__tstate);
32628 if (PyErr_Occurred()) SWIG_fail;
32629 }
32630 resultobj = SWIG_From_int(static_cast< int >(result));
32631 return resultobj;
32632 fail:
32633 return NULL;
32634 }
32635
32636
32637 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32638 PyObject *resultobj = 0;
32639 wxWindow *arg1 = (wxWindow *) 0 ;
32640 int result;
32641 void *argp1 = 0 ;
32642 int res1 = 0 ;
32643 PyObject *swig_obj[1] ;
32644
32645 if (!args) SWIG_fail;
32646 swig_obj[0] = args;
32647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32648 if (!SWIG_IsOK(res1)) {
32649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32650 }
32651 arg1 = reinterpret_cast< wxWindow * >(argp1);
32652 {
32653 PyThreadState* __tstate = wxPyBeginAllowThreads();
32654 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32655 wxPyEndAllowThreads(__tstate);
32656 if (PyErr_Occurred()) SWIG_fail;
32657 }
32658 resultobj = SWIG_From_int(static_cast< int >(result));
32659 return resultobj;
32660 fail:
32661 return NULL;
32662 }
32663
32664
32665 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32666 PyObject *resultobj = 0;
32667 wxWindow *arg1 = (wxWindow *) 0 ;
32668 int result;
32669 void *argp1 = 0 ;
32670 int res1 = 0 ;
32671 PyObject *swig_obj[1] ;
32672
32673 if (!args) SWIG_fail;
32674 swig_obj[0] = args;
32675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32676 if (!SWIG_IsOK(res1)) {
32677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32678 }
32679 arg1 = reinterpret_cast< wxWindow * >(argp1);
32680 {
32681 PyThreadState* __tstate = wxPyBeginAllowThreads();
32682 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32683 wxPyEndAllowThreads(__tstate);
32684 if (PyErr_Occurred()) SWIG_fail;
32685 }
32686 resultobj = SWIG_From_int(static_cast< int >(result));
32687 return resultobj;
32688 fail:
32689 return NULL;
32690 }
32691
32692
32693 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32694 PyObject *resultobj = 0;
32695 wxWindow *arg1 = (wxWindow *) 0 ;
32696 int result;
32697 void *argp1 = 0 ;
32698 int res1 = 0 ;
32699 PyObject *swig_obj[1] ;
32700
32701 if (!args) SWIG_fail;
32702 swig_obj[0] = args;
32703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32704 if (!SWIG_IsOK(res1)) {
32705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32706 }
32707 arg1 = reinterpret_cast< wxWindow * >(argp1);
32708 {
32709 PyThreadState* __tstate = wxPyBeginAllowThreads();
32710 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32711 wxPyEndAllowThreads(__tstate);
32712 if (PyErr_Occurred()) SWIG_fail;
32713 }
32714 resultobj = SWIG_From_int(static_cast< int >(result));
32715 return resultobj;
32716 fail:
32717 return NULL;
32718 }
32719
32720
32721 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32722 PyObject *resultobj = 0;
32723 wxWindow *arg1 = (wxWindow *) 0 ;
32724 wxSize *arg2 = 0 ;
32725 void *argp1 = 0 ;
32726 int res1 = 0 ;
32727 wxSize temp2 ;
32728 PyObject * obj0 = 0 ;
32729 PyObject * obj1 = 0 ;
32730 char * kwnames[] = {
32731 (char *) "self",(char *) "size", NULL
32732 };
32733
32734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32736 if (!SWIG_IsOK(res1)) {
32737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32738 }
32739 arg1 = reinterpret_cast< wxWindow * >(argp1);
32740 {
32741 arg2 = &temp2;
32742 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32743 }
32744 {
32745 PyThreadState* __tstate = wxPyBeginAllowThreads();
32746 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32747 wxPyEndAllowThreads(__tstate);
32748 if (PyErr_Occurred()) SWIG_fail;
32749 }
32750 resultobj = SWIG_Py_Void();
32751 return resultobj;
32752 fail:
32753 return NULL;
32754 }
32755
32756
32757 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32758 PyObject *resultobj = 0;
32759 wxWindow *arg1 = (wxWindow *) 0 ;
32760 int arg2 ;
32761 int arg3 ;
32762 void *argp1 = 0 ;
32763 int res1 = 0 ;
32764 int val2 ;
32765 int ecode2 = 0 ;
32766 int val3 ;
32767 int ecode3 = 0 ;
32768 PyObject * obj0 = 0 ;
32769 PyObject * obj1 = 0 ;
32770 PyObject * obj2 = 0 ;
32771 char * kwnames[] = {
32772 (char *) "self",(char *) "w",(char *) "h", NULL
32773 };
32774
32775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32779 }
32780 arg1 = reinterpret_cast< wxWindow * >(argp1);
32781 ecode2 = SWIG_AsVal_int(obj1, &val2);
32782 if (!SWIG_IsOK(ecode2)) {
32783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32784 }
32785 arg2 = static_cast< int >(val2);
32786 ecode3 = SWIG_AsVal_int(obj2, &val3);
32787 if (!SWIG_IsOK(ecode3)) {
32788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32789 }
32790 arg3 = static_cast< int >(val3);
32791 {
32792 PyThreadState* __tstate = wxPyBeginAllowThreads();
32793 (arg1)->SetVirtualSize(arg2,arg3);
32794 wxPyEndAllowThreads(__tstate);
32795 if (PyErr_Occurred()) SWIG_fail;
32796 }
32797 resultobj = SWIG_Py_Void();
32798 return resultobj;
32799 fail:
32800 return NULL;
32801 }
32802
32803
32804 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32805 PyObject *resultobj = 0;
32806 wxWindow *arg1 = (wxWindow *) 0 ;
32807 wxSize result;
32808 void *argp1 = 0 ;
32809 int res1 = 0 ;
32810 PyObject *swig_obj[1] ;
32811
32812 if (!args) SWIG_fail;
32813 swig_obj[0] = args;
32814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32815 if (!SWIG_IsOK(res1)) {
32816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32817 }
32818 arg1 = reinterpret_cast< wxWindow * >(argp1);
32819 {
32820 PyThreadState* __tstate = wxPyBeginAllowThreads();
32821 result = ((wxWindow const *)arg1)->GetVirtualSize();
32822 wxPyEndAllowThreads(__tstate);
32823 if (PyErr_Occurred()) SWIG_fail;
32824 }
32825 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32826 return resultobj;
32827 fail:
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32833 PyObject *resultobj = 0;
32834 wxWindow *arg1 = (wxWindow *) 0 ;
32835 int *arg2 = (int *) 0 ;
32836 int *arg3 = (int *) 0 ;
32837 void *argp1 = 0 ;
32838 int res1 = 0 ;
32839 int temp2 ;
32840 int res2 = SWIG_TMPOBJ ;
32841 int temp3 ;
32842 int res3 = SWIG_TMPOBJ ;
32843 PyObject *swig_obj[1] ;
32844
32845 arg2 = &temp2;
32846 arg3 = &temp3;
32847 if (!args) SWIG_fail;
32848 swig_obj[0] = args;
32849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32852 }
32853 arg1 = reinterpret_cast< wxWindow * >(argp1);
32854 {
32855 PyThreadState* __tstate = wxPyBeginAllowThreads();
32856 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 resultobj = SWIG_Py_Void();
32861 if (SWIG_IsTmpObj(res2)) {
32862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32863 } else {
32864 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32866 }
32867 if (SWIG_IsTmpObj(res3)) {
32868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32869 } else {
32870 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32872 }
32873 return resultobj;
32874 fail:
32875 return NULL;
32876 }
32877
32878
32879 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32880 PyObject *resultobj = 0;
32881 wxWindow *arg1 = (wxWindow *) 0 ;
32882 wxSize result;
32883 void *argp1 = 0 ;
32884 int res1 = 0 ;
32885 PyObject *swig_obj[1] ;
32886
32887 if (!args) SWIG_fail;
32888 swig_obj[0] = args;
32889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32890 if (!SWIG_IsOK(res1)) {
32891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32892 }
32893 arg1 = reinterpret_cast< wxWindow * >(argp1);
32894 {
32895 PyThreadState* __tstate = wxPyBeginAllowThreads();
32896 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32897 wxPyEndAllowThreads(__tstate);
32898 if (PyErr_Occurred()) SWIG_fail;
32899 }
32900 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32901 return resultobj;
32902 fail:
32903 return NULL;
32904 }
32905
32906
32907 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32908 PyObject *resultobj = 0;
32909 wxWindow *arg1 = (wxWindow *) 0 ;
32910 bool arg2 = (bool) true ;
32911 bool result;
32912 void *argp1 = 0 ;
32913 int res1 = 0 ;
32914 bool val2 ;
32915 int ecode2 = 0 ;
32916 PyObject * obj0 = 0 ;
32917 PyObject * obj1 = 0 ;
32918 char * kwnames[] = {
32919 (char *) "self",(char *) "show", NULL
32920 };
32921
32922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32924 if (!SWIG_IsOK(res1)) {
32925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32926 }
32927 arg1 = reinterpret_cast< wxWindow * >(argp1);
32928 if (obj1) {
32929 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32930 if (!SWIG_IsOK(ecode2)) {
32931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32932 }
32933 arg2 = static_cast< bool >(val2);
32934 }
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 result = (bool)(arg1)->Show(arg2);
32938 wxPyEndAllowThreads(__tstate);
32939 if (PyErr_Occurred()) SWIG_fail;
32940 }
32941 {
32942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32943 }
32944 return resultobj;
32945 fail:
32946 return NULL;
32947 }
32948
32949
32950 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32951 PyObject *resultobj = 0;
32952 wxWindow *arg1 = (wxWindow *) 0 ;
32953 bool result;
32954 void *argp1 = 0 ;
32955 int res1 = 0 ;
32956 PyObject *swig_obj[1] ;
32957
32958 if (!args) SWIG_fail;
32959 swig_obj[0] = args;
32960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32961 if (!SWIG_IsOK(res1)) {
32962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32963 }
32964 arg1 = reinterpret_cast< wxWindow * >(argp1);
32965 {
32966 PyThreadState* __tstate = wxPyBeginAllowThreads();
32967 result = (bool)(arg1)->Hide();
32968 wxPyEndAllowThreads(__tstate);
32969 if (PyErr_Occurred()) SWIG_fail;
32970 }
32971 {
32972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32973 }
32974 return resultobj;
32975 fail:
32976 return NULL;
32977 }
32978
32979
32980 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32981 PyObject *resultobj = 0;
32982 wxWindow *arg1 = (wxWindow *) 0 ;
32983 bool arg2 = (bool) true ;
32984 bool result;
32985 void *argp1 = 0 ;
32986 int res1 = 0 ;
32987 bool val2 ;
32988 int ecode2 = 0 ;
32989 PyObject * obj0 = 0 ;
32990 PyObject * obj1 = 0 ;
32991 char * kwnames[] = {
32992 (char *) "self",(char *) "enable", NULL
32993 };
32994
32995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32997 if (!SWIG_IsOK(res1)) {
32998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32999 }
33000 arg1 = reinterpret_cast< wxWindow * >(argp1);
33001 if (obj1) {
33002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33003 if (!SWIG_IsOK(ecode2)) {
33004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33005 }
33006 arg2 = static_cast< bool >(val2);
33007 }
33008 {
33009 PyThreadState* __tstate = wxPyBeginAllowThreads();
33010 result = (bool)(arg1)->Enable(arg2);
33011 wxPyEndAllowThreads(__tstate);
33012 if (PyErr_Occurred()) SWIG_fail;
33013 }
33014 {
33015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33016 }
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33024 PyObject *resultobj = 0;
33025 wxWindow *arg1 = (wxWindow *) 0 ;
33026 bool result;
33027 void *argp1 = 0 ;
33028 int res1 = 0 ;
33029 PyObject *swig_obj[1] ;
33030
33031 if (!args) SWIG_fail;
33032 swig_obj[0] = args;
33033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33034 if (!SWIG_IsOK(res1)) {
33035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33036 }
33037 arg1 = reinterpret_cast< wxWindow * >(argp1);
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 result = (bool)(arg1)->Disable();
33041 wxPyEndAllowThreads(__tstate);
33042 if (PyErr_Occurred()) SWIG_fail;
33043 }
33044 {
33045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33046 }
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33054 PyObject *resultobj = 0;
33055 wxWindow *arg1 = (wxWindow *) 0 ;
33056 bool result;
33057 void *argp1 = 0 ;
33058 int res1 = 0 ;
33059 PyObject *swig_obj[1] ;
33060
33061 if (!args) SWIG_fail;
33062 swig_obj[0] = args;
33063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33064 if (!SWIG_IsOK(res1)) {
33065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33066 }
33067 arg1 = reinterpret_cast< wxWindow * >(argp1);
33068 {
33069 PyThreadState* __tstate = wxPyBeginAllowThreads();
33070 result = (bool)((wxWindow const *)arg1)->IsShown();
33071 wxPyEndAllowThreads(__tstate);
33072 if (PyErr_Occurred()) SWIG_fail;
33073 }
33074 {
33075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33076 }
33077 return resultobj;
33078 fail:
33079 return NULL;
33080 }
33081
33082
33083 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33084 PyObject *resultobj = 0;
33085 wxWindow *arg1 = (wxWindow *) 0 ;
33086 bool result;
33087 void *argp1 = 0 ;
33088 int res1 = 0 ;
33089 PyObject *swig_obj[1] ;
33090
33091 if (!args) SWIG_fail;
33092 swig_obj[0] = args;
33093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33096 }
33097 arg1 = reinterpret_cast< wxWindow * >(argp1);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 {
33105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33106 }
33107 return resultobj;
33108 fail:
33109 return NULL;
33110 }
33111
33112
33113 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33114 PyObject *resultobj = 0;
33115 wxWindow *arg1 = (wxWindow *) 0 ;
33116 bool result;
33117 void *argp1 = 0 ;
33118 int res1 = 0 ;
33119 PyObject *swig_obj[1] ;
33120
33121 if (!args) SWIG_fail;
33122 swig_obj[0] = args;
33123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33124 if (!SWIG_IsOK(res1)) {
33125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33126 }
33127 arg1 = reinterpret_cast< wxWindow * >(argp1);
33128 {
33129 PyThreadState* __tstate = wxPyBeginAllowThreads();
33130 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33131 wxPyEndAllowThreads(__tstate);
33132 if (PyErr_Occurred()) SWIG_fail;
33133 }
33134 {
33135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33136 }
33137 return resultobj;
33138 fail:
33139 return NULL;
33140 }
33141
33142
33143 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33144 PyObject *resultobj = 0;
33145 wxWindow *arg1 = (wxWindow *) 0 ;
33146 long arg2 ;
33147 void *argp1 = 0 ;
33148 int res1 = 0 ;
33149 long val2 ;
33150 int ecode2 = 0 ;
33151 PyObject * obj0 = 0 ;
33152 PyObject * obj1 = 0 ;
33153 char * kwnames[] = {
33154 (char *) "self",(char *) "style", NULL
33155 };
33156
33157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33159 if (!SWIG_IsOK(res1)) {
33160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33161 }
33162 arg1 = reinterpret_cast< wxWindow * >(argp1);
33163 ecode2 = SWIG_AsVal_long(obj1, &val2);
33164 if (!SWIG_IsOK(ecode2)) {
33165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33166 }
33167 arg2 = static_cast< long >(val2);
33168 {
33169 PyThreadState* __tstate = wxPyBeginAllowThreads();
33170 (arg1)->SetWindowStyleFlag(arg2);
33171 wxPyEndAllowThreads(__tstate);
33172 if (PyErr_Occurred()) SWIG_fail;
33173 }
33174 resultobj = SWIG_Py_Void();
33175 return resultobj;
33176 fail:
33177 return NULL;
33178 }
33179
33180
33181 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33182 PyObject *resultobj = 0;
33183 wxWindow *arg1 = (wxWindow *) 0 ;
33184 long result;
33185 void *argp1 = 0 ;
33186 int res1 = 0 ;
33187 PyObject *swig_obj[1] ;
33188
33189 if (!args) SWIG_fail;
33190 swig_obj[0] = args;
33191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33192 if (!SWIG_IsOK(res1)) {
33193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33194 }
33195 arg1 = reinterpret_cast< wxWindow * >(argp1);
33196 {
33197 PyThreadState* __tstate = wxPyBeginAllowThreads();
33198 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33199 wxPyEndAllowThreads(__tstate);
33200 if (PyErr_Occurred()) SWIG_fail;
33201 }
33202 resultobj = SWIG_From_long(static_cast< long >(result));
33203 return resultobj;
33204 fail:
33205 return NULL;
33206 }
33207
33208
33209 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33210 PyObject *resultobj = 0;
33211 wxWindow *arg1 = (wxWindow *) 0 ;
33212 int arg2 ;
33213 bool result;
33214 void *argp1 = 0 ;
33215 int res1 = 0 ;
33216 int val2 ;
33217 int ecode2 = 0 ;
33218 PyObject * obj0 = 0 ;
33219 PyObject * obj1 = 0 ;
33220 char * kwnames[] = {
33221 (char *) "self",(char *) "flag", NULL
33222 };
33223
33224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33226 if (!SWIG_IsOK(res1)) {
33227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33228 }
33229 arg1 = reinterpret_cast< wxWindow * >(argp1);
33230 ecode2 = SWIG_AsVal_int(obj1, &val2);
33231 if (!SWIG_IsOK(ecode2)) {
33232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33233 }
33234 arg2 = static_cast< int >(val2);
33235 {
33236 PyThreadState* __tstate = wxPyBeginAllowThreads();
33237 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 {
33242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33243 }
33244 return resultobj;
33245 fail:
33246 return NULL;
33247 }
33248
33249
33250 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33251 PyObject *resultobj = 0;
33252 wxWindow *arg1 = (wxWindow *) 0 ;
33253 bool result;
33254 void *argp1 = 0 ;
33255 int res1 = 0 ;
33256 PyObject *swig_obj[1] ;
33257
33258 if (!args) SWIG_fail;
33259 swig_obj[0] = args;
33260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33261 if (!SWIG_IsOK(res1)) {
33262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33263 }
33264 arg1 = reinterpret_cast< wxWindow * >(argp1);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 result = (bool)((wxWindow const *)arg1)->IsRetained();
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 {
33272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33273 }
33274 return resultobj;
33275 fail:
33276 return NULL;
33277 }
33278
33279
33280 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33281 PyObject *resultobj = 0;
33282 wxWindow *arg1 = (wxWindow *) 0 ;
33283 long arg2 ;
33284 void *argp1 = 0 ;
33285 int res1 = 0 ;
33286 long val2 ;
33287 int ecode2 = 0 ;
33288 PyObject * obj0 = 0 ;
33289 PyObject * obj1 = 0 ;
33290 char * kwnames[] = {
33291 (char *) "self",(char *) "exStyle", NULL
33292 };
33293
33294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33296 if (!SWIG_IsOK(res1)) {
33297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33298 }
33299 arg1 = reinterpret_cast< wxWindow * >(argp1);
33300 ecode2 = SWIG_AsVal_long(obj1, &val2);
33301 if (!SWIG_IsOK(ecode2)) {
33302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33303 }
33304 arg2 = static_cast< long >(val2);
33305 {
33306 PyThreadState* __tstate = wxPyBeginAllowThreads();
33307 (arg1)->SetExtraStyle(arg2);
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 resultobj = SWIG_Py_Void();
33312 return resultobj;
33313 fail:
33314 return NULL;
33315 }
33316
33317
33318 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33319 PyObject *resultobj = 0;
33320 wxWindow *arg1 = (wxWindow *) 0 ;
33321 long result;
33322 void *argp1 = 0 ;
33323 int res1 = 0 ;
33324 PyObject *swig_obj[1] ;
33325
33326 if (!args) SWIG_fail;
33327 swig_obj[0] = args;
33328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33329 if (!SWIG_IsOK(res1)) {
33330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33331 }
33332 arg1 = reinterpret_cast< wxWindow * >(argp1);
33333 {
33334 PyThreadState* __tstate = wxPyBeginAllowThreads();
33335 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33336 wxPyEndAllowThreads(__tstate);
33337 if (PyErr_Occurred()) SWIG_fail;
33338 }
33339 resultobj = SWIG_From_long(static_cast< long >(result));
33340 return resultobj;
33341 fail:
33342 return NULL;
33343 }
33344
33345
33346 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33347 PyObject *resultobj = 0;
33348 wxWindow *arg1 = (wxWindow *) 0 ;
33349 bool arg2 = (bool) true ;
33350 void *argp1 = 0 ;
33351 int res1 = 0 ;
33352 bool val2 ;
33353 int ecode2 = 0 ;
33354 PyObject * obj0 = 0 ;
33355 PyObject * obj1 = 0 ;
33356 char * kwnames[] = {
33357 (char *) "self",(char *) "modal", NULL
33358 };
33359
33360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33362 if (!SWIG_IsOK(res1)) {
33363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33364 }
33365 arg1 = reinterpret_cast< wxWindow * >(argp1);
33366 if (obj1) {
33367 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33368 if (!SWIG_IsOK(ecode2)) {
33369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33370 }
33371 arg2 = static_cast< bool >(val2);
33372 }
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 (arg1)->MakeModal(arg2);
33376 wxPyEndAllowThreads(__tstate);
33377 if (PyErr_Occurred()) SWIG_fail;
33378 }
33379 resultobj = SWIG_Py_Void();
33380 return resultobj;
33381 fail:
33382 return NULL;
33383 }
33384
33385
33386 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33387 PyObject *resultobj = 0;
33388 wxWindow *arg1 = (wxWindow *) 0 ;
33389 bool arg2 ;
33390 void *argp1 = 0 ;
33391 int res1 = 0 ;
33392 bool val2 ;
33393 int ecode2 = 0 ;
33394 PyObject * obj0 = 0 ;
33395 PyObject * obj1 = 0 ;
33396 char * kwnames[] = {
33397 (char *) "self",(char *) "enableTheme", NULL
33398 };
33399
33400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33402 if (!SWIG_IsOK(res1)) {
33403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33404 }
33405 arg1 = reinterpret_cast< wxWindow * >(argp1);
33406 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33407 if (!SWIG_IsOK(ecode2)) {
33408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33409 }
33410 arg2 = static_cast< bool >(val2);
33411 {
33412 PyThreadState* __tstate = wxPyBeginAllowThreads();
33413 (arg1)->SetThemeEnabled(arg2);
33414 wxPyEndAllowThreads(__tstate);
33415 if (PyErr_Occurred()) SWIG_fail;
33416 }
33417 resultobj = SWIG_Py_Void();
33418 return resultobj;
33419 fail:
33420 return NULL;
33421 }
33422
33423
33424 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33425 PyObject *resultobj = 0;
33426 wxWindow *arg1 = (wxWindow *) 0 ;
33427 bool result;
33428 void *argp1 = 0 ;
33429 int res1 = 0 ;
33430 PyObject *swig_obj[1] ;
33431
33432 if (!args) SWIG_fail;
33433 swig_obj[0] = args;
33434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33435 if (!SWIG_IsOK(res1)) {
33436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33437 }
33438 arg1 = reinterpret_cast< wxWindow * >(argp1);
33439 {
33440 PyThreadState* __tstate = wxPyBeginAllowThreads();
33441 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33442 wxPyEndAllowThreads(__tstate);
33443 if (PyErr_Occurred()) SWIG_fail;
33444 }
33445 {
33446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33447 }
33448 return resultobj;
33449 fail:
33450 return NULL;
33451 }
33452
33453
33454 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33455 PyObject *resultobj = 0;
33456 wxWindow *arg1 = (wxWindow *) 0 ;
33457 void *argp1 = 0 ;
33458 int res1 = 0 ;
33459 PyObject *swig_obj[1] ;
33460
33461 if (!args) SWIG_fail;
33462 swig_obj[0] = args;
33463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33464 if (!SWIG_IsOK(res1)) {
33465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33466 }
33467 arg1 = reinterpret_cast< wxWindow * >(argp1);
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 (arg1)->SetFocus();
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 resultobj = SWIG_Py_Void();
33475 return resultobj;
33476 fail:
33477 return NULL;
33478 }
33479
33480
33481 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33482 PyObject *resultobj = 0;
33483 wxWindow *arg1 = (wxWindow *) 0 ;
33484 void *argp1 = 0 ;
33485 int res1 = 0 ;
33486 PyObject *swig_obj[1] ;
33487
33488 if (!args) SWIG_fail;
33489 swig_obj[0] = args;
33490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33491 if (!SWIG_IsOK(res1)) {
33492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33493 }
33494 arg1 = reinterpret_cast< wxWindow * >(argp1);
33495 {
33496 PyThreadState* __tstate = wxPyBeginAllowThreads();
33497 (arg1)->SetFocusFromKbd();
33498 wxPyEndAllowThreads(__tstate);
33499 if (PyErr_Occurred()) SWIG_fail;
33500 }
33501 resultobj = SWIG_Py_Void();
33502 return resultobj;
33503 fail:
33504 return NULL;
33505 }
33506
33507
33508 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33509 PyObject *resultobj = 0;
33510 wxWindow *result = 0 ;
33511
33512 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33513 {
33514 if (!wxPyCheckForApp()) SWIG_fail;
33515 PyThreadState* __tstate = wxPyBeginAllowThreads();
33516 result = (wxWindow *)wxWindow::FindFocus();
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 {
33521 resultobj = wxPyMake_wxObject(result, 0);
33522 }
33523 return resultobj;
33524 fail:
33525 return NULL;
33526 }
33527
33528
33529 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33530 PyObject *resultobj = 0;
33531 wxWindow *arg1 = (wxWindow *) 0 ;
33532 bool result;
33533 void *argp1 = 0 ;
33534 int res1 = 0 ;
33535 PyObject *swig_obj[1] ;
33536
33537 if (!args) SWIG_fail;
33538 swig_obj[0] = args;
33539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33540 if (!SWIG_IsOK(res1)) {
33541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33542 }
33543 arg1 = reinterpret_cast< wxWindow * >(argp1);
33544 {
33545 PyThreadState* __tstate = wxPyBeginAllowThreads();
33546 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33547 wxPyEndAllowThreads(__tstate);
33548 if (PyErr_Occurred()) SWIG_fail;
33549 }
33550 {
33551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33552 }
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 bool result;
33563 void *argp1 = 0 ;
33564 int res1 = 0 ;
33565 PyObject *swig_obj[1] ;
33566
33567 if (!args) SWIG_fail;
33568 swig_obj[0] = args;
33569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33570 if (!SWIG_IsOK(res1)) {
33571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33572 }
33573 arg1 = reinterpret_cast< wxWindow * >(argp1);
33574 {
33575 PyThreadState* __tstate = wxPyBeginAllowThreads();
33576 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33577 wxPyEndAllowThreads(__tstate);
33578 if (PyErr_Occurred()) SWIG_fail;
33579 }
33580 {
33581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33582 }
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33590 PyObject *resultobj = 0;
33591 wxWindow *arg1 = (wxWindow *) 0 ;
33592 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33593 bool result;
33594 void *argp1 = 0 ;
33595 int res1 = 0 ;
33596 int val2 ;
33597 int ecode2 = 0 ;
33598 PyObject * obj0 = 0 ;
33599 PyObject * obj1 = 0 ;
33600 char * kwnames[] = {
33601 (char *) "self",(char *) "flags", NULL
33602 };
33603
33604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33606 if (!SWIG_IsOK(res1)) {
33607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33608 }
33609 arg1 = reinterpret_cast< wxWindow * >(argp1);
33610 if (obj1) {
33611 ecode2 = SWIG_AsVal_int(obj1, &val2);
33612 if (!SWIG_IsOK(ecode2)) {
33613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33614 }
33615 arg2 = static_cast< int >(val2);
33616 }
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 result = (bool)(arg1)->Navigate(arg2);
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 {
33624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33625 }
33626 return resultobj;
33627 fail:
33628 return NULL;
33629 }
33630
33631
33632 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33633 PyObject *resultobj = 0;
33634 wxWindow *arg1 = (wxWindow *) 0 ;
33635 wxWindow *arg2 = (wxWindow *) 0 ;
33636 void *argp1 = 0 ;
33637 int res1 = 0 ;
33638 void *argp2 = 0 ;
33639 int res2 = 0 ;
33640 PyObject * obj0 = 0 ;
33641 PyObject * obj1 = 0 ;
33642 char * kwnames[] = {
33643 (char *) "self",(char *) "win", NULL
33644 };
33645
33646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33648 if (!SWIG_IsOK(res1)) {
33649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33650 }
33651 arg1 = reinterpret_cast< wxWindow * >(argp1);
33652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33653 if (!SWIG_IsOK(res2)) {
33654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33655 }
33656 arg2 = reinterpret_cast< wxWindow * >(argp2);
33657 {
33658 PyThreadState* __tstate = wxPyBeginAllowThreads();
33659 (arg1)->MoveAfterInTabOrder(arg2);
33660 wxPyEndAllowThreads(__tstate);
33661 if (PyErr_Occurred()) SWIG_fail;
33662 }
33663 resultobj = SWIG_Py_Void();
33664 return resultobj;
33665 fail:
33666 return NULL;
33667 }
33668
33669
33670 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33671 PyObject *resultobj = 0;
33672 wxWindow *arg1 = (wxWindow *) 0 ;
33673 wxWindow *arg2 = (wxWindow *) 0 ;
33674 void *argp1 = 0 ;
33675 int res1 = 0 ;
33676 void *argp2 = 0 ;
33677 int res2 = 0 ;
33678 PyObject * obj0 = 0 ;
33679 PyObject * obj1 = 0 ;
33680 char * kwnames[] = {
33681 (char *) "self",(char *) "win", NULL
33682 };
33683
33684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33686 if (!SWIG_IsOK(res1)) {
33687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33688 }
33689 arg1 = reinterpret_cast< wxWindow * >(argp1);
33690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33691 if (!SWIG_IsOK(res2)) {
33692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33693 }
33694 arg2 = reinterpret_cast< wxWindow * >(argp2);
33695 {
33696 PyThreadState* __tstate = wxPyBeginAllowThreads();
33697 (arg1)->MoveBeforeInTabOrder(arg2);
33698 wxPyEndAllowThreads(__tstate);
33699 if (PyErr_Occurred()) SWIG_fail;
33700 }
33701 resultobj = SWIG_Py_Void();
33702 return resultobj;
33703 fail:
33704 return NULL;
33705 }
33706
33707
33708 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33709 PyObject *resultobj = 0;
33710 wxWindow *arg1 = (wxWindow *) 0 ;
33711 PyObject *result = 0 ;
33712 void *argp1 = 0 ;
33713 int res1 = 0 ;
33714 PyObject *swig_obj[1] ;
33715
33716 if (!args) SWIG_fail;
33717 swig_obj[0] = args;
33718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33719 if (!SWIG_IsOK(res1)) {
33720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33721 }
33722 arg1 = reinterpret_cast< wxWindow * >(argp1);
33723 {
33724 PyThreadState* __tstate = wxPyBeginAllowThreads();
33725 result = (PyObject *)wxWindow_GetChildren(arg1);
33726 wxPyEndAllowThreads(__tstate);
33727 if (PyErr_Occurred()) SWIG_fail;
33728 }
33729 resultobj = result;
33730 return resultobj;
33731 fail:
33732 return NULL;
33733 }
33734
33735
33736 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33737 PyObject *resultobj = 0;
33738 wxWindow *arg1 = (wxWindow *) 0 ;
33739 wxWindow *result = 0 ;
33740 void *argp1 = 0 ;
33741 int res1 = 0 ;
33742 PyObject *swig_obj[1] ;
33743
33744 if (!args) SWIG_fail;
33745 swig_obj[0] = args;
33746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33747 if (!SWIG_IsOK(res1)) {
33748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33749 }
33750 arg1 = reinterpret_cast< wxWindow * >(argp1);
33751 {
33752 PyThreadState* __tstate = wxPyBeginAllowThreads();
33753 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33754 wxPyEndAllowThreads(__tstate);
33755 if (PyErr_Occurred()) SWIG_fail;
33756 }
33757 {
33758 resultobj = wxPyMake_wxObject(result, 0);
33759 }
33760 return resultobj;
33761 fail:
33762 return NULL;
33763 }
33764
33765
33766 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33767 PyObject *resultobj = 0;
33768 wxWindow *arg1 = (wxWindow *) 0 ;
33769 wxWindow *result = 0 ;
33770 void *argp1 = 0 ;
33771 int res1 = 0 ;
33772 PyObject *swig_obj[1] ;
33773
33774 if (!args) SWIG_fail;
33775 swig_obj[0] = args;
33776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33777 if (!SWIG_IsOK(res1)) {
33778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33779 }
33780 arg1 = reinterpret_cast< wxWindow * >(argp1);
33781 {
33782 PyThreadState* __tstate = wxPyBeginAllowThreads();
33783 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 {
33788 resultobj = wxPyMake_wxObject(result, 0);
33789 }
33790 return resultobj;
33791 fail:
33792 return NULL;
33793 }
33794
33795
33796 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33797 PyObject *resultobj = 0;
33798 wxWindow *arg1 = (wxWindow *) 0 ;
33799 bool result;
33800 void *argp1 = 0 ;
33801 int res1 = 0 ;
33802 PyObject *swig_obj[1] ;
33803
33804 if (!args) SWIG_fail;
33805 swig_obj[0] = args;
33806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33807 if (!SWIG_IsOK(res1)) {
33808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33809 }
33810 arg1 = reinterpret_cast< wxWindow * >(argp1);
33811 {
33812 PyThreadState* __tstate = wxPyBeginAllowThreads();
33813 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33814 wxPyEndAllowThreads(__tstate);
33815 if (PyErr_Occurred()) SWIG_fail;
33816 }
33817 {
33818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33819 }
33820 return resultobj;
33821 fail:
33822 return NULL;
33823 }
33824
33825
33826 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33827 PyObject *resultobj = 0;
33828 wxWindow *arg1 = (wxWindow *) 0 ;
33829 wxWindow *arg2 = (wxWindow *) 0 ;
33830 bool result;
33831 void *argp1 = 0 ;
33832 int res1 = 0 ;
33833 void *argp2 = 0 ;
33834 int res2 = 0 ;
33835 PyObject * obj0 = 0 ;
33836 PyObject * obj1 = 0 ;
33837 char * kwnames[] = {
33838 (char *) "self",(char *) "newParent", NULL
33839 };
33840
33841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33843 if (!SWIG_IsOK(res1)) {
33844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33845 }
33846 arg1 = reinterpret_cast< wxWindow * >(argp1);
33847 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33848 if (!SWIG_IsOK(res2)) {
33849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33850 }
33851 arg2 = reinterpret_cast< wxWindow * >(argp2);
33852 {
33853 PyThreadState* __tstate = wxPyBeginAllowThreads();
33854 result = (bool)(arg1)->Reparent(arg2);
33855 wxPyEndAllowThreads(__tstate);
33856 if (PyErr_Occurred()) SWIG_fail;
33857 }
33858 {
33859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33860 }
33861 return resultobj;
33862 fail:
33863 return NULL;
33864 }
33865
33866
33867 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33868 PyObject *resultobj = 0;
33869 wxWindow *arg1 = (wxWindow *) 0 ;
33870 wxWindow *arg2 = (wxWindow *) 0 ;
33871 void *argp1 = 0 ;
33872 int res1 = 0 ;
33873 void *argp2 = 0 ;
33874 int res2 = 0 ;
33875 PyObject * obj0 = 0 ;
33876 PyObject * obj1 = 0 ;
33877 char * kwnames[] = {
33878 (char *) "self",(char *) "child", NULL
33879 };
33880
33881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33885 }
33886 arg1 = reinterpret_cast< wxWindow * >(argp1);
33887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33888 if (!SWIG_IsOK(res2)) {
33889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33890 }
33891 arg2 = reinterpret_cast< wxWindow * >(argp2);
33892 {
33893 PyThreadState* __tstate = wxPyBeginAllowThreads();
33894 (arg1)->AddChild(arg2);
33895 wxPyEndAllowThreads(__tstate);
33896 if (PyErr_Occurred()) SWIG_fail;
33897 }
33898 resultobj = SWIG_Py_Void();
33899 return resultobj;
33900 fail:
33901 return NULL;
33902 }
33903
33904
33905 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33906 PyObject *resultobj = 0;
33907 wxWindow *arg1 = (wxWindow *) 0 ;
33908 wxWindow *arg2 = (wxWindow *) 0 ;
33909 void *argp1 = 0 ;
33910 int res1 = 0 ;
33911 void *argp2 = 0 ;
33912 int res2 = 0 ;
33913 PyObject * obj0 = 0 ;
33914 PyObject * obj1 = 0 ;
33915 char * kwnames[] = {
33916 (char *) "self",(char *) "child", NULL
33917 };
33918
33919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33921 if (!SWIG_IsOK(res1)) {
33922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33923 }
33924 arg1 = reinterpret_cast< wxWindow * >(argp1);
33925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33926 if (!SWIG_IsOK(res2)) {
33927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33928 }
33929 arg2 = reinterpret_cast< wxWindow * >(argp2);
33930 {
33931 PyThreadState* __tstate = wxPyBeginAllowThreads();
33932 (arg1)->RemoveChild(arg2);
33933 wxPyEndAllowThreads(__tstate);
33934 if (PyErr_Occurred()) SWIG_fail;
33935 }
33936 resultobj = SWIG_Py_Void();
33937 return resultobj;
33938 fail:
33939 return NULL;
33940 }
33941
33942
33943 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33944 PyObject *resultobj = 0;
33945 wxWindow *arg1 = (wxWindow *) 0 ;
33946 bool arg2 ;
33947 void *argp1 = 0 ;
33948 int res1 = 0 ;
33949 bool val2 ;
33950 int ecode2 = 0 ;
33951 PyObject * obj0 = 0 ;
33952 PyObject * obj1 = 0 ;
33953 char * kwnames[] = {
33954 (char *) "self",(char *) "on", NULL
33955 };
33956
33957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33959 if (!SWIG_IsOK(res1)) {
33960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33961 }
33962 arg1 = reinterpret_cast< wxWindow * >(argp1);
33963 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33964 if (!SWIG_IsOK(ecode2)) {
33965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33966 }
33967 arg2 = static_cast< bool >(val2);
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 wxWindow_SetDoubleBuffered(arg1,arg2);
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 resultobj = SWIG_Py_Void();
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj = 0;
33983 wxWindow *arg1 = (wxWindow *) 0 ;
33984 long arg2 ;
33985 wxWindow *result = 0 ;
33986 void *argp1 = 0 ;
33987 int res1 = 0 ;
33988 long val2 ;
33989 int ecode2 = 0 ;
33990 PyObject * obj0 = 0 ;
33991 PyObject * obj1 = 0 ;
33992 char * kwnames[] = {
33993 (char *) "self",(char *) "winid", NULL
33994 };
33995
33996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33998 if (!SWIG_IsOK(res1)) {
33999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34000 }
34001 arg1 = reinterpret_cast< wxWindow * >(argp1);
34002 ecode2 = SWIG_AsVal_long(obj1, &val2);
34003 if (!SWIG_IsOK(ecode2)) {
34004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34005 }
34006 arg2 = static_cast< long >(val2);
34007 {
34008 PyThreadState* __tstate = wxPyBeginAllowThreads();
34009 result = (wxWindow *)(arg1)->FindWindow(arg2);
34010 wxPyEndAllowThreads(__tstate);
34011 if (PyErr_Occurred()) SWIG_fail;
34012 }
34013 {
34014 resultobj = wxPyMake_wxObject(result, 0);
34015 }
34016 return resultobj;
34017 fail:
34018 return NULL;
34019 }
34020
34021
34022 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34023 PyObject *resultobj = 0;
34024 wxWindow *arg1 = (wxWindow *) 0 ;
34025 wxString *arg2 = 0 ;
34026 wxWindow *result = 0 ;
34027 void *argp1 = 0 ;
34028 int res1 = 0 ;
34029 bool temp2 = false ;
34030 PyObject * obj0 = 0 ;
34031 PyObject * obj1 = 0 ;
34032 char * kwnames[] = {
34033 (char *) "self",(char *) "name", NULL
34034 };
34035
34036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34038 if (!SWIG_IsOK(res1)) {
34039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34040 }
34041 arg1 = reinterpret_cast< wxWindow * >(argp1);
34042 {
34043 arg2 = wxString_in_helper(obj1);
34044 if (arg2 == NULL) SWIG_fail;
34045 temp2 = true;
34046 }
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 {
34054 resultobj = wxPyMake_wxObject(result, 0);
34055 }
34056 {
34057 if (temp2)
34058 delete arg2;
34059 }
34060 return resultobj;
34061 fail:
34062 {
34063 if (temp2)
34064 delete arg2;
34065 }
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34071 PyObject *resultobj = 0;
34072 wxWindow *arg1 = (wxWindow *) 0 ;
34073 wxEvtHandler *result = 0 ;
34074 void *argp1 = 0 ;
34075 int res1 = 0 ;
34076 PyObject *swig_obj[1] ;
34077
34078 if (!args) SWIG_fail;
34079 swig_obj[0] = args;
34080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 {
34086 PyThreadState* __tstate = wxPyBeginAllowThreads();
34087 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34088 wxPyEndAllowThreads(__tstate);
34089 if (PyErr_Occurred()) SWIG_fail;
34090 }
34091 {
34092 resultobj = wxPyMake_wxObject(result, 0);
34093 }
34094 return resultobj;
34095 fail:
34096 return NULL;
34097 }
34098
34099
34100 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34101 PyObject *resultobj = 0;
34102 wxWindow *arg1 = (wxWindow *) 0 ;
34103 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34104 void *argp1 = 0 ;
34105 int res1 = 0 ;
34106 void *argp2 = 0 ;
34107 int res2 = 0 ;
34108 PyObject * obj0 = 0 ;
34109 PyObject * obj1 = 0 ;
34110 char * kwnames[] = {
34111 (char *) "self",(char *) "handler", NULL
34112 };
34113
34114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34121 if (!SWIG_IsOK(res2)) {
34122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34123 }
34124 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 (arg1)->SetEventHandler(arg2);
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 resultobj = SWIG_Py_Void();
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34139 PyObject *resultobj = 0;
34140 wxWindow *arg1 = (wxWindow *) 0 ;
34141 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34142 void *argp1 = 0 ;
34143 int res1 = 0 ;
34144 void *argp2 = 0 ;
34145 int res2 = 0 ;
34146 PyObject * obj0 = 0 ;
34147 PyObject * obj1 = 0 ;
34148 char * kwnames[] = {
34149 (char *) "self",(char *) "handler", NULL
34150 };
34151
34152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34154 if (!SWIG_IsOK(res1)) {
34155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34156 }
34157 arg1 = reinterpret_cast< wxWindow * >(argp1);
34158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34159 if (!SWIG_IsOK(res2)) {
34160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34161 }
34162 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34163 {
34164 PyThreadState* __tstate = wxPyBeginAllowThreads();
34165 (arg1)->PushEventHandler(arg2);
34166 wxPyEndAllowThreads(__tstate);
34167 if (PyErr_Occurred()) SWIG_fail;
34168 }
34169 resultobj = SWIG_Py_Void();
34170 return resultobj;
34171 fail:
34172 return NULL;
34173 }
34174
34175
34176 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34177 PyObject *resultobj = 0;
34178 wxWindow *arg1 = (wxWindow *) 0 ;
34179 bool arg2 = (bool) false ;
34180 wxEvtHandler *result = 0 ;
34181 void *argp1 = 0 ;
34182 int res1 = 0 ;
34183 bool val2 ;
34184 int ecode2 = 0 ;
34185 PyObject * obj0 = 0 ;
34186 PyObject * obj1 = 0 ;
34187 char * kwnames[] = {
34188 (char *) "self",(char *) "deleteHandler", NULL
34189 };
34190
34191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34193 if (!SWIG_IsOK(res1)) {
34194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34195 }
34196 arg1 = reinterpret_cast< wxWindow * >(argp1);
34197 if (obj1) {
34198 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34199 if (!SWIG_IsOK(ecode2)) {
34200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34201 }
34202 arg2 = static_cast< bool >(val2);
34203 }
34204 {
34205 PyThreadState* __tstate = wxPyBeginAllowThreads();
34206 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34207 wxPyEndAllowThreads(__tstate);
34208 if (PyErr_Occurred()) SWIG_fail;
34209 }
34210 {
34211 resultobj = wxPyMake_wxObject(result, 0);
34212 }
34213 return resultobj;
34214 fail:
34215 return NULL;
34216 }
34217
34218
34219 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34220 PyObject *resultobj = 0;
34221 wxWindow *arg1 = (wxWindow *) 0 ;
34222 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34223 bool result;
34224 void *argp1 = 0 ;
34225 int res1 = 0 ;
34226 void *argp2 = 0 ;
34227 int res2 = 0 ;
34228 PyObject * obj0 = 0 ;
34229 PyObject * obj1 = 0 ;
34230 char * kwnames[] = {
34231 (char *) "self",(char *) "handler", NULL
34232 };
34233
34234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34241 if (!SWIG_IsOK(res2)) {
34242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34243 }
34244 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34245 {
34246 PyThreadState* __tstate = wxPyBeginAllowThreads();
34247 result = (bool)(arg1)->RemoveEventHandler(arg2);
34248 wxPyEndAllowThreads(__tstate);
34249 if (PyErr_Occurred()) SWIG_fail;
34250 }
34251 {
34252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34253 }
34254 return resultobj;
34255 fail:
34256 return NULL;
34257 }
34258
34259
34260 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34261 PyObject *resultobj = 0;
34262 wxWindow *arg1 = (wxWindow *) 0 ;
34263 wxValidator *arg2 = 0 ;
34264 void *argp1 = 0 ;
34265 int res1 = 0 ;
34266 void *argp2 = 0 ;
34267 int res2 = 0 ;
34268 PyObject * obj0 = 0 ;
34269 PyObject * obj1 = 0 ;
34270 char * kwnames[] = {
34271 (char *) "self",(char *) "validator", NULL
34272 };
34273
34274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34276 if (!SWIG_IsOK(res1)) {
34277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34278 }
34279 arg1 = reinterpret_cast< wxWindow * >(argp1);
34280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34281 if (!SWIG_IsOK(res2)) {
34282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34283 }
34284 if (!argp2) {
34285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34286 }
34287 arg2 = reinterpret_cast< wxValidator * >(argp2);
34288 {
34289 PyThreadState* __tstate = wxPyBeginAllowThreads();
34290 (arg1)->SetValidator((wxValidator const &)*arg2);
34291 wxPyEndAllowThreads(__tstate);
34292 if (PyErr_Occurred()) SWIG_fail;
34293 }
34294 resultobj = SWIG_Py_Void();
34295 return resultobj;
34296 fail:
34297 return NULL;
34298 }
34299
34300
34301 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34302 PyObject *resultobj = 0;
34303 wxWindow *arg1 = (wxWindow *) 0 ;
34304 wxValidator *result = 0 ;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 PyObject *swig_obj[1] ;
34308
34309 if (!args) SWIG_fail;
34310 swig_obj[0] = args;
34311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34312 if (!SWIG_IsOK(res1)) {
34313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34314 }
34315 arg1 = reinterpret_cast< wxWindow * >(argp1);
34316 {
34317 PyThreadState* __tstate = wxPyBeginAllowThreads();
34318 result = (wxValidator *)(arg1)->GetValidator();
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 {
34323 resultobj = wxPyMake_wxObject(result, (bool)0);
34324 }
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34332 PyObject *resultobj = 0;
34333 wxWindow *arg1 = (wxWindow *) 0 ;
34334 bool result;
34335 void *argp1 = 0 ;
34336 int res1 = 0 ;
34337 PyObject *swig_obj[1] ;
34338
34339 if (!args) SWIG_fail;
34340 swig_obj[0] = args;
34341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34342 if (!SWIG_IsOK(res1)) {
34343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34344 }
34345 arg1 = reinterpret_cast< wxWindow * >(argp1);
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 result = (bool)(arg1)->Validate();
34349 wxPyEndAllowThreads(__tstate);
34350 if (PyErr_Occurred()) SWIG_fail;
34351 }
34352 {
34353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34354 }
34355 return resultobj;
34356 fail:
34357 return NULL;
34358 }
34359
34360
34361 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34362 PyObject *resultobj = 0;
34363 wxWindow *arg1 = (wxWindow *) 0 ;
34364 bool result;
34365 void *argp1 = 0 ;
34366 int res1 = 0 ;
34367 PyObject *swig_obj[1] ;
34368
34369 if (!args) SWIG_fail;
34370 swig_obj[0] = args;
34371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34372 if (!SWIG_IsOK(res1)) {
34373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34374 }
34375 arg1 = reinterpret_cast< wxWindow * >(argp1);
34376 {
34377 PyThreadState* __tstate = wxPyBeginAllowThreads();
34378 result = (bool)(arg1)->TransferDataToWindow();
34379 wxPyEndAllowThreads(__tstate);
34380 if (PyErr_Occurred()) SWIG_fail;
34381 }
34382 {
34383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34384 }
34385 return resultobj;
34386 fail:
34387 return NULL;
34388 }
34389
34390
34391 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34392 PyObject *resultobj = 0;
34393 wxWindow *arg1 = (wxWindow *) 0 ;
34394 bool result;
34395 void *argp1 = 0 ;
34396 int res1 = 0 ;
34397 PyObject *swig_obj[1] ;
34398
34399 if (!args) SWIG_fail;
34400 swig_obj[0] = args;
34401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34402 if (!SWIG_IsOK(res1)) {
34403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34404 }
34405 arg1 = reinterpret_cast< wxWindow * >(argp1);
34406 {
34407 PyThreadState* __tstate = wxPyBeginAllowThreads();
34408 result = (bool)(arg1)->TransferDataFromWindow();
34409 wxPyEndAllowThreads(__tstate);
34410 if (PyErr_Occurred()) SWIG_fail;
34411 }
34412 {
34413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34414 }
34415 return resultobj;
34416 fail:
34417 return NULL;
34418 }
34419
34420
34421 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34422 PyObject *resultobj = 0;
34423 wxWindow *arg1 = (wxWindow *) 0 ;
34424 void *argp1 = 0 ;
34425 int res1 = 0 ;
34426 PyObject *swig_obj[1] ;
34427
34428 if (!args) SWIG_fail;
34429 swig_obj[0] = args;
34430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34431 if (!SWIG_IsOK(res1)) {
34432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34433 }
34434 arg1 = reinterpret_cast< wxWindow * >(argp1);
34435 {
34436 PyThreadState* __tstate = wxPyBeginAllowThreads();
34437 (arg1)->InitDialog();
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 resultobj = SWIG_Py_Void();
34442 return resultobj;
34443 fail:
34444 return NULL;
34445 }
34446
34447
34448 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34449 PyObject *resultobj = 0;
34450 wxWindow *arg1 = (wxWindow *) 0 ;
34451 wxAcceleratorTable *arg2 = 0 ;
34452 void *argp1 = 0 ;
34453 int res1 = 0 ;
34454 void *argp2 = 0 ;
34455 int res2 = 0 ;
34456 PyObject * obj0 = 0 ;
34457 PyObject * obj1 = 0 ;
34458 char * kwnames[] = {
34459 (char *) "self",(char *) "accel", NULL
34460 };
34461
34462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34464 if (!SWIG_IsOK(res1)) {
34465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34466 }
34467 arg1 = reinterpret_cast< wxWindow * >(argp1);
34468 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34469 if (!SWIG_IsOK(res2)) {
34470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34471 }
34472 if (!argp2) {
34473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34474 }
34475 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 resultobj = SWIG_Py_Void();
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34490 PyObject *resultobj = 0;
34491 wxWindow *arg1 = (wxWindow *) 0 ;
34492 wxAcceleratorTable *result = 0 ;
34493 void *argp1 = 0 ;
34494 int res1 = 0 ;
34495 PyObject *swig_obj[1] ;
34496
34497 if (!args) SWIG_fail;
34498 swig_obj[0] = args;
34499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34502 }
34503 arg1 = reinterpret_cast< wxWindow * >(argp1);
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 int arg2 ;
34521 int arg3 ;
34522 int arg4 ;
34523 bool result;
34524 void *argp1 = 0 ;
34525 int res1 = 0 ;
34526 int val2 ;
34527 int ecode2 = 0 ;
34528 int val3 ;
34529 int ecode3 = 0 ;
34530 int val4 ;
34531 int ecode4 = 0 ;
34532 PyObject * obj0 = 0 ;
34533 PyObject * obj1 = 0 ;
34534 PyObject * obj2 = 0 ;
34535 PyObject * obj3 = 0 ;
34536 char * kwnames[] = {
34537 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34538 };
34539
34540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34542 if (!SWIG_IsOK(res1)) {
34543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34544 }
34545 arg1 = reinterpret_cast< wxWindow * >(argp1);
34546 ecode2 = SWIG_AsVal_int(obj1, &val2);
34547 if (!SWIG_IsOK(ecode2)) {
34548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34549 }
34550 arg2 = static_cast< int >(val2);
34551 ecode3 = SWIG_AsVal_int(obj2, &val3);
34552 if (!SWIG_IsOK(ecode3)) {
34553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34554 }
34555 arg3 = static_cast< int >(val3);
34556 ecode4 = SWIG_AsVal_int(obj3, &val4);
34557 if (!SWIG_IsOK(ecode4)) {
34558 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34559 }
34560 arg4 = static_cast< int >(val4);
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 {
34568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34569 }
34570 return resultobj;
34571 fail:
34572 return NULL;
34573 }
34574
34575
34576 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34577 PyObject *resultobj = 0;
34578 wxWindow *arg1 = (wxWindow *) 0 ;
34579 int arg2 ;
34580 bool result;
34581 void *argp1 = 0 ;
34582 int res1 = 0 ;
34583 int val2 ;
34584 int ecode2 = 0 ;
34585 PyObject * obj0 = 0 ;
34586 PyObject * obj1 = 0 ;
34587 char * kwnames[] = {
34588 (char *) "self",(char *) "hotkeyId", NULL
34589 };
34590
34591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34593 if (!SWIG_IsOK(res1)) {
34594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34595 }
34596 arg1 = reinterpret_cast< wxWindow * >(argp1);
34597 ecode2 = SWIG_AsVal_int(obj1, &val2);
34598 if (!SWIG_IsOK(ecode2)) {
34599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34600 }
34601 arg2 = static_cast< int >(val2);
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34605 wxPyEndAllowThreads(__tstate);
34606 if (PyErr_Occurred()) SWIG_fail;
34607 }
34608 {
34609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34610 }
34611 return resultobj;
34612 fail:
34613 return NULL;
34614 }
34615
34616
34617 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34618 PyObject *resultobj = 0;
34619 wxWindow *arg1 = (wxWindow *) 0 ;
34620 wxPoint *arg2 = 0 ;
34621 wxPoint result;
34622 void *argp1 = 0 ;
34623 int res1 = 0 ;
34624 wxPoint temp2 ;
34625 PyObject * obj0 = 0 ;
34626 PyObject * obj1 = 0 ;
34627 char * kwnames[] = {
34628 (char *) "self",(char *) "pt", NULL
34629 };
34630
34631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34633 if (!SWIG_IsOK(res1)) {
34634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34635 }
34636 arg1 = reinterpret_cast< wxWindow * >(argp1);
34637 {
34638 arg2 = &temp2;
34639 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34640 }
34641 {
34642 PyThreadState* __tstate = wxPyBeginAllowThreads();
34643 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34644 wxPyEndAllowThreads(__tstate);
34645 if (PyErr_Occurred()) SWIG_fail;
34646 }
34647 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34648 return resultobj;
34649 fail:
34650 return NULL;
34651 }
34652
34653
34654 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34655 PyObject *resultobj = 0;
34656 wxWindow *arg1 = (wxWindow *) 0 ;
34657 wxSize *arg2 = 0 ;
34658 wxSize result;
34659 void *argp1 = 0 ;
34660 int res1 = 0 ;
34661 wxSize temp2 ;
34662 PyObject * obj0 = 0 ;
34663 PyObject * obj1 = 0 ;
34664 char * kwnames[] = {
34665 (char *) "self",(char *) "sz", NULL
34666 };
34667
34668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34670 if (!SWIG_IsOK(res1)) {
34671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34672 }
34673 arg1 = reinterpret_cast< wxWindow * >(argp1);
34674 {
34675 arg2 = &temp2;
34676 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34677 }
34678 {
34679 PyThreadState* __tstate = wxPyBeginAllowThreads();
34680 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34685 return resultobj;
34686 fail:
34687 return NULL;
34688 }
34689
34690
34691 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34692 PyObject *resultobj = 0;
34693 wxWindow *arg1 = (wxWindow *) 0 ;
34694 wxPoint *arg2 = 0 ;
34695 wxPoint result;
34696 void *argp1 = 0 ;
34697 int res1 = 0 ;
34698 wxPoint temp2 ;
34699 PyObject * obj0 = 0 ;
34700 PyObject * obj1 = 0 ;
34701 char * kwnames[] = {
34702 (char *) "self",(char *) "pt", NULL
34703 };
34704
34705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34707 if (!SWIG_IsOK(res1)) {
34708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34709 }
34710 arg1 = reinterpret_cast< wxWindow * >(argp1);
34711 {
34712 arg2 = &temp2;
34713 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34714 }
34715 {
34716 PyThreadState* __tstate = wxPyBeginAllowThreads();
34717 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34722 return resultobj;
34723 fail:
34724 return NULL;
34725 }
34726
34727
34728 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34729 PyObject *resultobj = 0;
34730 wxWindow *arg1 = (wxWindow *) 0 ;
34731 wxSize *arg2 = 0 ;
34732 wxSize result;
34733 void *argp1 = 0 ;
34734 int res1 = 0 ;
34735 wxSize temp2 ;
34736 PyObject * obj0 = 0 ;
34737 PyObject * obj1 = 0 ;
34738 char * kwnames[] = {
34739 (char *) "self",(char *) "sz", NULL
34740 };
34741
34742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34744 if (!SWIG_IsOK(res1)) {
34745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34746 }
34747 arg1 = reinterpret_cast< wxWindow * >(argp1);
34748 {
34749 arg2 = &temp2;
34750 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34751 }
34752 {
34753 PyThreadState* __tstate = wxPyBeginAllowThreads();
34754 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34755 wxPyEndAllowThreads(__tstate);
34756 if (PyErr_Occurred()) SWIG_fail;
34757 }
34758 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34759 return resultobj;
34760 fail:
34761 return NULL;
34762 }
34763
34764
34765 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34766 PyObject *resultobj = 0;
34767 wxWindow *arg1 = (wxWindow *) 0 ;
34768 wxPoint *arg2 = 0 ;
34769 wxPoint result;
34770 void *argp1 = 0 ;
34771 int res1 = 0 ;
34772 wxPoint temp2 ;
34773 PyObject * obj0 = 0 ;
34774 PyObject * obj1 = 0 ;
34775 char * kwnames[] = {
34776 (char *) "self",(char *) "pt", NULL
34777 };
34778
34779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34781 if (!SWIG_IsOK(res1)) {
34782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34783 }
34784 arg1 = reinterpret_cast< wxWindow * >(argp1);
34785 {
34786 arg2 = &temp2;
34787 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34788 }
34789 {
34790 PyThreadState* __tstate = wxPyBeginAllowThreads();
34791 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34792 wxPyEndAllowThreads(__tstate);
34793 if (PyErr_Occurred()) SWIG_fail;
34794 }
34795 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34796 return resultobj;
34797 fail:
34798 return NULL;
34799 }
34800
34801
34802 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34803 PyObject *resultobj = 0;
34804 wxWindow *arg1 = (wxWindow *) 0 ;
34805 wxSize *arg2 = 0 ;
34806 wxSize result;
34807 void *argp1 = 0 ;
34808 int res1 = 0 ;
34809 wxSize temp2 ;
34810 PyObject * obj0 = 0 ;
34811 PyObject * obj1 = 0 ;
34812 char * kwnames[] = {
34813 (char *) "self",(char *) "sz", NULL
34814 };
34815
34816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34818 if (!SWIG_IsOK(res1)) {
34819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34820 }
34821 arg1 = reinterpret_cast< wxWindow * >(argp1);
34822 {
34823 arg2 = &temp2;
34824 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34825 }
34826 {
34827 PyThreadState* __tstate = wxPyBeginAllowThreads();
34828 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34829 wxPyEndAllowThreads(__tstate);
34830 if (PyErr_Occurred()) SWIG_fail;
34831 }
34832 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34833 return resultobj;
34834 fail:
34835 return NULL;
34836 }
34837
34838
34839 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34840 PyObject *resultobj = 0;
34841 wxWindow *arg1 = (wxWindow *) 0 ;
34842 int arg2 ;
34843 int arg3 ;
34844 void *argp1 = 0 ;
34845 int res1 = 0 ;
34846 int val2 ;
34847 int ecode2 = 0 ;
34848 int val3 ;
34849 int ecode3 = 0 ;
34850 PyObject * obj0 = 0 ;
34851 PyObject * obj1 = 0 ;
34852 PyObject * obj2 = 0 ;
34853 char * kwnames[] = {
34854 (char *) "self",(char *) "x",(char *) "y", NULL
34855 };
34856
34857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 ecode2 = SWIG_AsVal_int(obj1, &val2);
34864 if (!SWIG_IsOK(ecode2)) {
34865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34866 }
34867 arg2 = static_cast< int >(val2);
34868 ecode3 = SWIG_AsVal_int(obj2, &val3);
34869 if (!SWIG_IsOK(ecode3)) {
34870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34871 }
34872 arg3 = static_cast< int >(val3);
34873 {
34874 PyThreadState* __tstate = wxPyBeginAllowThreads();
34875 (arg1)->WarpPointer(arg2,arg3);
34876 wxPyEndAllowThreads(__tstate);
34877 if (PyErr_Occurred()) SWIG_fail;
34878 }
34879 resultobj = SWIG_Py_Void();
34880 return resultobj;
34881 fail:
34882 return NULL;
34883 }
34884
34885
34886 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34887 PyObject *resultobj = 0;
34888 wxWindow *arg1 = (wxWindow *) 0 ;
34889 void *argp1 = 0 ;
34890 int res1 = 0 ;
34891 PyObject *swig_obj[1] ;
34892
34893 if (!args) SWIG_fail;
34894 swig_obj[0] = args;
34895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34898 }
34899 arg1 = reinterpret_cast< wxWindow * >(argp1);
34900 {
34901 PyThreadState* __tstate = wxPyBeginAllowThreads();
34902 (arg1)->CaptureMouse();
34903 wxPyEndAllowThreads(__tstate);
34904 if (PyErr_Occurred()) SWIG_fail;
34905 }
34906 resultobj = SWIG_Py_Void();
34907 return resultobj;
34908 fail:
34909 return NULL;
34910 }
34911
34912
34913 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34914 PyObject *resultobj = 0;
34915 wxWindow *arg1 = (wxWindow *) 0 ;
34916 void *argp1 = 0 ;
34917 int res1 = 0 ;
34918 PyObject *swig_obj[1] ;
34919
34920 if (!args) SWIG_fail;
34921 swig_obj[0] = args;
34922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34923 if (!SWIG_IsOK(res1)) {
34924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34925 }
34926 arg1 = reinterpret_cast< wxWindow * >(argp1);
34927 {
34928 PyThreadState* __tstate = wxPyBeginAllowThreads();
34929 (arg1)->ReleaseMouse();
34930 wxPyEndAllowThreads(__tstate);
34931 if (PyErr_Occurred()) SWIG_fail;
34932 }
34933 resultobj = SWIG_Py_Void();
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34941 PyObject *resultobj = 0;
34942 wxWindow *result = 0 ;
34943
34944 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34945 {
34946 if (!wxPyCheckForApp()) SWIG_fail;
34947 PyThreadState* __tstate = wxPyBeginAllowThreads();
34948 result = (wxWindow *)wxWindow::GetCapture();
34949 wxPyEndAllowThreads(__tstate);
34950 if (PyErr_Occurred()) SWIG_fail;
34951 }
34952 {
34953 resultobj = wxPyMake_wxObject(result, 0);
34954 }
34955 return resultobj;
34956 fail:
34957 return NULL;
34958 }
34959
34960
34961 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34962 PyObject *resultobj = 0;
34963 wxWindow *arg1 = (wxWindow *) 0 ;
34964 bool result;
34965 void *argp1 = 0 ;
34966 int res1 = 0 ;
34967 PyObject *swig_obj[1] ;
34968
34969 if (!args) SWIG_fail;
34970 swig_obj[0] = args;
34971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34972 if (!SWIG_IsOK(res1)) {
34973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34974 }
34975 arg1 = reinterpret_cast< wxWindow * >(argp1);
34976 {
34977 PyThreadState* __tstate = wxPyBeginAllowThreads();
34978 result = (bool)((wxWindow const *)arg1)->HasCapture();
34979 wxPyEndAllowThreads(__tstate);
34980 if (PyErr_Occurred()) SWIG_fail;
34981 }
34982 {
34983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34984 }
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34992 PyObject *resultobj = 0;
34993 wxWindow *arg1 = (wxWindow *) 0 ;
34994 bool arg2 = (bool) true ;
34995 wxRect *arg3 = (wxRect *) NULL ;
34996 void *argp1 = 0 ;
34997 int res1 = 0 ;
34998 bool val2 ;
34999 int ecode2 = 0 ;
35000 void *argp3 = 0 ;
35001 int res3 = 0 ;
35002 PyObject * obj0 = 0 ;
35003 PyObject * obj1 = 0 ;
35004 PyObject * obj2 = 0 ;
35005 char * kwnames[] = {
35006 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35007 };
35008
35009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35011 if (!SWIG_IsOK(res1)) {
35012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35013 }
35014 arg1 = reinterpret_cast< wxWindow * >(argp1);
35015 if (obj1) {
35016 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35017 if (!SWIG_IsOK(ecode2)) {
35018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35019 }
35020 arg2 = static_cast< bool >(val2);
35021 }
35022 if (obj2) {
35023 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35024 if (!SWIG_IsOK(res3)) {
35025 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35026 }
35027 arg3 = reinterpret_cast< wxRect * >(argp3);
35028 }
35029 {
35030 PyThreadState* __tstate = wxPyBeginAllowThreads();
35031 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 resultobj = SWIG_Py_Void();
35036 return resultobj;
35037 fail:
35038 return NULL;
35039 }
35040
35041
35042 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35043 PyObject *resultobj = 0;
35044 wxWindow *arg1 = (wxWindow *) 0 ;
35045 wxRect *arg2 = 0 ;
35046 bool arg3 = (bool) true ;
35047 void *argp1 = 0 ;
35048 int res1 = 0 ;
35049 wxRect temp2 ;
35050 bool val3 ;
35051 int ecode3 = 0 ;
35052 PyObject * obj0 = 0 ;
35053 PyObject * obj1 = 0 ;
35054 PyObject * obj2 = 0 ;
35055 char * kwnames[] = {
35056 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35057 };
35058
35059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35061 if (!SWIG_IsOK(res1)) {
35062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35063 }
35064 arg1 = reinterpret_cast< wxWindow * >(argp1);
35065 {
35066 arg2 = &temp2;
35067 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35068 }
35069 if (obj2) {
35070 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35071 if (!SWIG_IsOK(ecode3)) {
35072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35073 }
35074 arg3 = static_cast< bool >(val3);
35075 }
35076 {
35077 PyThreadState* __tstate = wxPyBeginAllowThreads();
35078 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35079 wxPyEndAllowThreads(__tstate);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 }
35082 resultobj = SWIG_Py_Void();
35083 return resultobj;
35084 fail:
35085 return NULL;
35086 }
35087
35088
35089 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35090 PyObject *resultobj = 0;
35091 wxWindow *arg1 = (wxWindow *) 0 ;
35092 void *argp1 = 0 ;
35093 int res1 = 0 ;
35094 PyObject *swig_obj[1] ;
35095
35096 if (!args) SWIG_fail;
35097 swig_obj[0] = args;
35098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35099 if (!SWIG_IsOK(res1)) {
35100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35101 }
35102 arg1 = reinterpret_cast< wxWindow * >(argp1);
35103 {
35104 PyThreadState* __tstate = wxPyBeginAllowThreads();
35105 (arg1)->Update();
35106 wxPyEndAllowThreads(__tstate);
35107 if (PyErr_Occurred()) SWIG_fail;
35108 }
35109 resultobj = SWIG_Py_Void();
35110 return resultobj;
35111 fail:
35112 return NULL;
35113 }
35114
35115
35116 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35117 PyObject *resultobj = 0;
35118 wxWindow *arg1 = (wxWindow *) 0 ;
35119 void *argp1 = 0 ;
35120 int res1 = 0 ;
35121 PyObject *swig_obj[1] ;
35122
35123 if (!args) SWIG_fail;
35124 swig_obj[0] = args;
35125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35128 }
35129 arg1 = reinterpret_cast< wxWindow * >(argp1);
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 (arg1)->ClearBackground();
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_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35144 PyObject *resultobj = 0;
35145 wxWindow *arg1 = (wxWindow *) 0 ;
35146 void *argp1 = 0 ;
35147 int res1 = 0 ;
35148 PyObject *swig_obj[1] ;
35149
35150 if (!args) SWIG_fail;
35151 swig_obj[0] = args;
35152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35153 if (!SWIG_IsOK(res1)) {
35154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35155 }
35156 arg1 = reinterpret_cast< wxWindow * >(argp1);
35157 {
35158 PyThreadState* __tstate = wxPyBeginAllowThreads();
35159 (arg1)->Freeze();
35160 wxPyEndAllowThreads(__tstate);
35161 if (PyErr_Occurred()) SWIG_fail;
35162 }
35163 resultobj = SWIG_Py_Void();
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35171 PyObject *resultobj = 0;
35172 wxWindow *arg1 = (wxWindow *) 0 ;
35173 bool result;
35174 void *argp1 = 0 ;
35175 int res1 = 0 ;
35176 PyObject *swig_obj[1] ;
35177
35178 if (!args) SWIG_fail;
35179 swig_obj[0] = args;
35180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35183 }
35184 arg1 = reinterpret_cast< wxWindow * >(argp1);
35185 {
35186 PyThreadState* __tstate = wxPyBeginAllowThreads();
35187 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 {
35192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35193 }
35194 return resultobj;
35195 fail:
35196 return NULL;
35197 }
35198
35199
35200 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35201 PyObject *resultobj = 0;
35202 wxWindow *arg1 = (wxWindow *) 0 ;
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_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35212 }
35213 arg1 = reinterpret_cast< wxWindow * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 (arg1)->Thaw();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 resultobj = SWIG_Py_Void();
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35228 PyObject *resultobj = 0;
35229 wxWindow *arg1 = (wxWindow *) 0 ;
35230 wxDC *arg2 = 0 ;
35231 void *argp1 = 0 ;
35232 int res1 = 0 ;
35233 void *argp2 = 0 ;
35234 int res2 = 0 ;
35235 PyObject * obj0 = 0 ;
35236 PyObject * obj1 = 0 ;
35237 char * kwnames[] = {
35238 (char *) "self",(char *) "dc", NULL
35239 };
35240
35241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35245 }
35246 arg1 = reinterpret_cast< wxWindow * >(argp1);
35247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35248 if (!SWIG_IsOK(res2)) {
35249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35250 }
35251 if (!argp2) {
35252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35253 }
35254 arg2 = reinterpret_cast< wxDC * >(argp2);
35255 {
35256 PyThreadState* __tstate = wxPyBeginAllowThreads();
35257 (arg1)->PrepareDC(*arg2);
35258 wxPyEndAllowThreads(__tstate);
35259 if (PyErr_Occurred()) SWIG_fail;
35260 }
35261 resultobj = SWIG_Py_Void();
35262 return resultobj;
35263 fail:
35264 return NULL;
35265 }
35266
35267
35268 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35269 PyObject *resultobj = 0;
35270 wxWindow *arg1 = (wxWindow *) 0 ;
35271 wxRegion *result = 0 ;
35272 void *argp1 = 0 ;
35273 int res1 = 0 ;
35274 PyObject *swig_obj[1] ;
35275
35276 if (!args) SWIG_fail;
35277 swig_obj[0] = args;
35278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35279 if (!SWIG_IsOK(res1)) {
35280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35281 }
35282 arg1 = reinterpret_cast< wxWindow * >(argp1);
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 {
35286 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35287 result = (wxRegion *) &_result_ref;
35288 }
35289 wxPyEndAllowThreads(__tstate);
35290 if (PyErr_Occurred()) SWIG_fail;
35291 }
35292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35293 return resultobj;
35294 fail:
35295 return NULL;
35296 }
35297
35298
35299 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35300 PyObject *resultobj = 0;
35301 wxWindow *arg1 = (wxWindow *) 0 ;
35302 wxRect result;
35303 void *argp1 = 0 ;
35304 int res1 = 0 ;
35305 PyObject *swig_obj[1] ;
35306
35307 if (!args) SWIG_fail;
35308 swig_obj[0] = args;
35309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35310 if (!SWIG_IsOK(res1)) {
35311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35312 }
35313 arg1 = reinterpret_cast< wxWindow * >(argp1);
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35328 PyObject *resultobj = 0;
35329 wxWindow *arg1 = (wxWindow *) 0 ;
35330 int arg2 ;
35331 int arg3 ;
35332 int arg4 = (int) 1 ;
35333 int arg5 = (int) 1 ;
35334 bool result;
35335 void *argp1 = 0 ;
35336 int res1 = 0 ;
35337 int val2 ;
35338 int ecode2 = 0 ;
35339 int val3 ;
35340 int ecode3 = 0 ;
35341 int val4 ;
35342 int ecode4 = 0 ;
35343 int val5 ;
35344 int ecode5 = 0 ;
35345 PyObject * obj0 = 0 ;
35346 PyObject * obj1 = 0 ;
35347 PyObject * obj2 = 0 ;
35348 PyObject * obj3 = 0 ;
35349 PyObject * obj4 = 0 ;
35350 char * kwnames[] = {
35351 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35352 };
35353
35354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35356 if (!SWIG_IsOK(res1)) {
35357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35358 }
35359 arg1 = reinterpret_cast< wxWindow * >(argp1);
35360 ecode2 = SWIG_AsVal_int(obj1, &val2);
35361 if (!SWIG_IsOK(ecode2)) {
35362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35363 }
35364 arg2 = static_cast< int >(val2);
35365 ecode3 = SWIG_AsVal_int(obj2, &val3);
35366 if (!SWIG_IsOK(ecode3)) {
35367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35368 }
35369 arg3 = static_cast< int >(val3);
35370 if (obj3) {
35371 ecode4 = SWIG_AsVal_int(obj3, &val4);
35372 if (!SWIG_IsOK(ecode4)) {
35373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35374 }
35375 arg4 = static_cast< int >(val4);
35376 }
35377 if (obj4) {
35378 ecode5 = SWIG_AsVal_int(obj4, &val5);
35379 if (!SWIG_IsOK(ecode5)) {
35380 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35381 }
35382 arg5 = static_cast< int >(val5);
35383 }
35384 {
35385 PyThreadState* __tstate = wxPyBeginAllowThreads();
35386 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35387 wxPyEndAllowThreads(__tstate);
35388 if (PyErr_Occurred()) SWIG_fail;
35389 }
35390 {
35391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35392 }
35393 return resultobj;
35394 fail:
35395 return NULL;
35396 }
35397
35398
35399 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35400 PyObject *resultobj = 0;
35401 wxWindow *arg1 = (wxWindow *) 0 ;
35402 wxPoint *arg2 = 0 ;
35403 bool result;
35404 void *argp1 = 0 ;
35405 int res1 = 0 ;
35406 wxPoint temp2 ;
35407 PyObject * obj0 = 0 ;
35408 PyObject * obj1 = 0 ;
35409 char * kwnames[] = {
35410 (char *) "self",(char *) "pt", NULL
35411 };
35412
35413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35415 if (!SWIG_IsOK(res1)) {
35416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35417 }
35418 arg1 = reinterpret_cast< wxWindow * >(argp1);
35419 {
35420 arg2 = &temp2;
35421 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35422 }
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 {
35430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35431 }
35432 return resultobj;
35433 fail:
35434 return NULL;
35435 }
35436
35437
35438 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35439 PyObject *resultobj = 0;
35440 wxWindow *arg1 = (wxWindow *) 0 ;
35441 wxRect *arg2 = 0 ;
35442 bool result;
35443 void *argp1 = 0 ;
35444 int res1 = 0 ;
35445 wxRect temp2 ;
35446 PyObject * obj0 = 0 ;
35447 PyObject * obj1 = 0 ;
35448 char * kwnames[] = {
35449 (char *) "self",(char *) "rect", NULL
35450 };
35451
35452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35454 if (!SWIG_IsOK(res1)) {
35455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35456 }
35457 arg1 = reinterpret_cast< wxWindow * >(argp1);
35458 {
35459 arg2 = &temp2;
35460 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35461 }
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 {
35469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35470 }
35471 return resultobj;
35472 fail:
35473 return NULL;
35474 }
35475
35476
35477 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35478 PyObject *resultobj = 0;
35479 wxWindow *arg1 = (wxWindow *) 0 ;
35480 SwigValueWrapper<wxVisualAttributes > result;
35481 void *argp1 = 0 ;
35482 int res1 = 0 ;
35483 PyObject *swig_obj[1] ;
35484
35485 if (!args) SWIG_fail;
35486 swig_obj[0] = args;
35487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35488 if (!SWIG_IsOK(res1)) {
35489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35490 }
35491 arg1 = reinterpret_cast< wxWindow * >(argp1);
35492 {
35493 PyThreadState* __tstate = wxPyBeginAllowThreads();
35494 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35495 wxPyEndAllowThreads(__tstate);
35496 if (PyErr_Occurred()) SWIG_fail;
35497 }
35498 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35506 PyObject *resultobj = 0;
35507 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35508 SwigValueWrapper<wxVisualAttributes > result;
35509 int val1 ;
35510 int ecode1 = 0 ;
35511 PyObject * obj0 = 0 ;
35512 char * kwnames[] = {
35513 (char *) "variant", NULL
35514 };
35515
35516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35517 if (obj0) {
35518 ecode1 = SWIG_AsVal_int(obj0, &val1);
35519 if (!SWIG_IsOK(ecode1)) {
35520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35521 }
35522 arg1 = static_cast< wxWindowVariant >(val1);
35523 }
35524 {
35525 if (!wxPyCheckForApp()) SWIG_fail;
35526 PyThreadState* __tstate = wxPyBeginAllowThreads();
35527 result = wxWindow::GetClassDefaultAttributes(arg1);
35528 wxPyEndAllowThreads(__tstate);
35529 if (PyErr_Occurred()) SWIG_fail;
35530 }
35531 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35532 return resultobj;
35533 fail:
35534 return NULL;
35535 }
35536
35537
35538 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35539 PyObject *resultobj = 0;
35540 wxWindow *arg1 = (wxWindow *) 0 ;
35541 wxColour *arg2 = 0 ;
35542 bool result;
35543 void *argp1 = 0 ;
35544 int res1 = 0 ;
35545 wxColour temp2 ;
35546 PyObject * obj0 = 0 ;
35547 PyObject * obj1 = 0 ;
35548 char * kwnames[] = {
35549 (char *) "self",(char *) "colour", NULL
35550 };
35551
35552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35554 if (!SWIG_IsOK(res1)) {
35555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35556 }
35557 arg1 = reinterpret_cast< wxWindow * >(argp1);
35558 {
35559 arg2 = &temp2;
35560 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35561 }
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35565 wxPyEndAllowThreads(__tstate);
35566 if (PyErr_Occurred()) SWIG_fail;
35567 }
35568 {
35569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35570 }
35571 return resultobj;
35572 fail:
35573 return NULL;
35574 }
35575
35576
35577 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35578 PyObject *resultobj = 0;
35579 wxWindow *arg1 = (wxWindow *) 0 ;
35580 wxColour *arg2 = 0 ;
35581 void *argp1 = 0 ;
35582 int res1 = 0 ;
35583 wxColour temp2 ;
35584 PyObject * obj0 = 0 ;
35585 PyObject * obj1 = 0 ;
35586 char * kwnames[] = {
35587 (char *) "self",(char *) "colour", NULL
35588 };
35589
35590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35592 if (!SWIG_IsOK(res1)) {
35593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35594 }
35595 arg1 = reinterpret_cast< wxWindow * >(argp1);
35596 {
35597 arg2 = &temp2;
35598 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35599 }
35600 {
35601 PyThreadState* __tstate = wxPyBeginAllowThreads();
35602 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 resultobj = SWIG_Py_Void();
35607 return resultobj;
35608 fail:
35609 return NULL;
35610 }
35611
35612
35613 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35614 PyObject *resultobj = 0;
35615 wxWindow *arg1 = (wxWindow *) 0 ;
35616 wxColour *arg2 = 0 ;
35617 bool result;
35618 void *argp1 = 0 ;
35619 int res1 = 0 ;
35620 wxColour temp2 ;
35621 PyObject * obj0 = 0 ;
35622 PyObject * obj1 = 0 ;
35623 char * kwnames[] = {
35624 (char *) "self",(char *) "colour", NULL
35625 };
35626
35627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35629 if (!SWIG_IsOK(res1)) {
35630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35631 }
35632 arg1 = reinterpret_cast< wxWindow * >(argp1);
35633 {
35634 arg2 = &temp2;
35635 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35636 }
35637 {
35638 PyThreadState* __tstate = wxPyBeginAllowThreads();
35639 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35640 wxPyEndAllowThreads(__tstate);
35641 if (PyErr_Occurred()) SWIG_fail;
35642 }
35643 {
35644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35645 }
35646 return resultobj;
35647 fail:
35648 return NULL;
35649 }
35650
35651
35652 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35653 PyObject *resultobj = 0;
35654 wxWindow *arg1 = (wxWindow *) 0 ;
35655 wxColour *arg2 = 0 ;
35656 void *argp1 = 0 ;
35657 int res1 = 0 ;
35658 wxColour temp2 ;
35659 PyObject * obj0 = 0 ;
35660 PyObject * obj1 = 0 ;
35661 char * kwnames[] = {
35662 (char *) "self",(char *) "colour", NULL
35663 };
35664
35665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35667 if (!SWIG_IsOK(res1)) {
35668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35669 }
35670 arg1 = reinterpret_cast< wxWindow * >(argp1);
35671 {
35672 arg2 = &temp2;
35673 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35674 }
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 resultobj = SWIG_Py_Void();
35682 return resultobj;
35683 fail:
35684 return NULL;
35685 }
35686
35687
35688 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35689 PyObject *resultobj = 0;
35690 wxWindow *arg1 = (wxWindow *) 0 ;
35691 wxColour result;
35692 void *argp1 = 0 ;
35693 int res1 = 0 ;
35694 PyObject *swig_obj[1] ;
35695
35696 if (!args) SWIG_fail;
35697 swig_obj[0] = args;
35698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35699 if (!SWIG_IsOK(res1)) {
35700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35701 }
35702 arg1 = reinterpret_cast< wxWindow * >(argp1);
35703 {
35704 PyThreadState* __tstate = wxPyBeginAllowThreads();
35705 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35706 wxPyEndAllowThreads(__tstate);
35707 if (PyErr_Occurred()) SWIG_fail;
35708 }
35709 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35710 return resultobj;
35711 fail:
35712 return NULL;
35713 }
35714
35715
35716 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35717 PyObject *resultobj = 0;
35718 wxWindow *arg1 = (wxWindow *) 0 ;
35719 wxColour result;
35720 void *argp1 = 0 ;
35721 int res1 = 0 ;
35722 PyObject *swig_obj[1] ;
35723
35724 if (!args) SWIG_fail;
35725 swig_obj[0] = args;
35726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35727 if (!SWIG_IsOK(res1)) {
35728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35729 }
35730 arg1 = reinterpret_cast< wxWindow * >(argp1);
35731 {
35732 PyThreadState* __tstate = wxPyBeginAllowThreads();
35733 result = ((wxWindow const *)arg1)->GetForegroundColour();
35734 wxPyEndAllowThreads(__tstate);
35735 if (PyErr_Occurred()) SWIG_fail;
35736 }
35737 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35738 return resultobj;
35739 fail:
35740 return NULL;
35741 }
35742
35743
35744 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35745 PyObject *resultobj = 0;
35746 wxWindow *arg1 = (wxWindow *) 0 ;
35747 bool result;
35748 void *argp1 = 0 ;
35749 int res1 = 0 ;
35750 PyObject *swig_obj[1] ;
35751
35752 if (!args) SWIG_fail;
35753 swig_obj[0] = args;
35754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35755 if (!SWIG_IsOK(res1)) {
35756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35757 }
35758 arg1 = reinterpret_cast< wxWindow * >(argp1);
35759 {
35760 PyThreadState* __tstate = wxPyBeginAllowThreads();
35761 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35762 wxPyEndAllowThreads(__tstate);
35763 if (PyErr_Occurred()) SWIG_fail;
35764 }
35765 {
35766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35767 }
35768 return resultobj;
35769 fail:
35770 return NULL;
35771 }
35772
35773
35774 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35775 PyObject *resultobj = 0;
35776 wxWindow *arg1 = (wxWindow *) 0 ;
35777 bool result;
35778 void *argp1 = 0 ;
35779 int res1 = 0 ;
35780 PyObject *swig_obj[1] ;
35781
35782 if (!args) SWIG_fail;
35783 swig_obj[0] = args;
35784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35787 }
35788 arg1 = reinterpret_cast< wxWindow * >(argp1);
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 {
35796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35797 }
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35805 PyObject *resultobj = 0;
35806 wxWindow *arg1 = (wxWindow *) 0 ;
35807 wxBackgroundStyle arg2 ;
35808 bool result;
35809 void *argp1 = 0 ;
35810 int res1 = 0 ;
35811 int val2 ;
35812 int ecode2 = 0 ;
35813 PyObject * obj0 = 0 ;
35814 PyObject * obj1 = 0 ;
35815 char * kwnames[] = {
35816 (char *) "self",(char *) "style", NULL
35817 };
35818
35819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35821 if (!SWIG_IsOK(res1)) {
35822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35823 }
35824 arg1 = reinterpret_cast< wxWindow * >(argp1);
35825 ecode2 = SWIG_AsVal_int(obj1, &val2);
35826 if (!SWIG_IsOK(ecode2)) {
35827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35828 }
35829 arg2 = static_cast< wxBackgroundStyle >(val2);
35830 {
35831 PyThreadState* __tstate = wxPyBeginAllowThreads();
35832 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35833 wxPyEndAllowThreads(__tstate);
35834 if (PyErr_Occurred()) SWIG_fail;
35835 }
35836 {
35837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35838 }
35839 return resultobj;
35840 fail:
35841 return NULL;
35842 }
35843
35844
35845 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35846 PyObject *resultobj = 0;
35847 wxWindow *arg1 = (wxWindow *) 0 ;
35848 wxBackgroundStyle result;
35849 void *argp1 = 0 ;
35850 int res1 = 0 ;
35851 PyObject *swig_obj[1] ;
35852
35853 if (!args) SWIG_fail;
35854 swig_obj[0] = args;
35855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35856 if (!SWIG_IsOK(res1)) {
35857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35858 }
35859 arg1 = reinterpret_cast< wxWindow * >(argp1);
35860 {
35861 PyThreadState* __tstate = wxPyBeginAllowThreads();
35862 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 resultobj = SWIG_From_int(static_cast< int >(result));
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35874 PyObject *resultobj = 0;
35875 wxWindow *arg1 = (wxWindow *) 0 ;
35876 bool result;
35877 void *argp1 = 0 ;
35878 int res1 = 0 ;
35879 PyObject *swig_obj[1] ;
35880
35881 if (!args) SWIG_fail;
35882 swig_obj[0] = args;
35883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35884 if (!SWIG_IsOK(res1)) {
35885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35886 }
35887 arg1 = reinterpret_cast< wxWindow * >(argp1);
35888 {
35889 PyThreadState* __tstate = wxPyBeginAllowThreads();
35890 result = (bool)(arg1)->HasTransparentBackground();
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 {
35895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35896 }
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35904 PyObject *resultobj = 0;
35905 wxWindow *arg1 = (wxWindow *) 0 ;
35906 wxCursor *arg2 = 0 ;
35907 bool result;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 void *argp2 = 0 ;
35911 int res2 = 0 ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "cursor", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35922 }
35923 arg1 = reinterpret_cast< wxWindow * >(argp1);
35924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35925 if (!SWIG_IsOK(res2)) {
35926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35927 }
35928 if (!argp2) {
35929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35930 }
35931 arg2 = reinterpret_cast< wxCursor * >(argp2);
35932 {
35933 PyThreadState* __tstate = wxPyBeginAllowThreads();
35934 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35935 wxPyEndAllowThreads(__tstate);
35936 if (PyErr_Occurred()) SWIG_fail;
35937 }
35938 {
35939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35940 }
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35948 PyObject *resultobj = 0;
35949 wxWindow *arg1 = (wxWindow *) 0 ;
35950 wxCursor result;
35951 void *argp1 = 0 ;
35952 int res1 = 0 ;
35953 PyObject *swig_obj[1] ;
35954
35955 if (!args) SWIG_fail;
35956 swig_obj[0] = args;
35957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35960 }
35961 arg1 = reinterpret_cast< wxWindow * >(argp1);
35962 {
35963 PyThreadState* __tstate = wxPyBeginAllowThreads();
35964 result = (arg1)->GetCursor();
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35976 PyObject *resultobj = 0;
35977 wxWindow *arg1 = (wxWindow *) 0 ;
35978 wxFont *arg2 = 0 ;
35979 bool result;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 void *argp2 = 0 ;
35983 int res2 = 0 ;
35984 PyObject * obj0 = 0 ;
35985 PyObject * obj1 = 0 ;
35986 char * kwnames[] = {
35987 (char *) "self",(char *) "font", NULL
35988 };
35989
35990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35992 if (!SWIG_IsOK(res1)) {
35993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35994 }
35995 arg1 = reinterpret_cast< wxWindow * >(argp1);
35996 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35997 if (!SWIG_IsOK(res2)) {
35998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35999 }
36000 if (!argp2) {
36001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36002 }
36003 arg2 = reinterpret_cast< wxFont * >(argp2);
36004 {
36005 PyThreadState* __tstate = wxPyBeginAllowThreads();
36006 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 {
36011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36012 }
36013 return resultobj;
36014 fail:
36015 return NULL;
36016 }
36017
36018
36019 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36020 PyObject *resultobj = 0;
36021 wxWindow *arg1 = (wxWindow *) 0 ;
36022 wxFont *arg2 = 0 ;
36023 void *argp1 = 0 ;
36024 int res1 = 0 ;
36025 void *argp2 = 0 ;
36026 int res2 = 0 ;
36027 PyObject * obj0 = 0 ;
36028 PyObject * obj1 = 0 ;
36029 char * kwnames[] = {
36030 (char *) "self",(char *) "font", NULL
36031 };
36032
36033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36035 if (!SWIG_IsOK(res1)) {
36036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36037 }
36038 arg1 = reinterpret_cast< wxWindow * >(argp1);
36039 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36040 if (!SWIG_IsOK(res2)) {
36041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36042 }
36043 if (!argp2) {
36044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36045 }
36046 arg2 = reinterpret_cast< wxFont * >(argp2);
36047 {
36048 PyThreadState* __tstate = wxPyBeginAllowThreads();
36049 (arg1)->SetOwnFont((wxFont const &)*arg2);
36050 wxPyEndAllowThreads(__tstate);
36051 if (PyErr_Occurred()) SWIG_fail;
36052 }
36053 resultobj = SWIG_Py_Void();
36054 return resultobj;
36055 fail:
36056 return NULL;
36057 }
36058
36059
36060 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36061 PyObject *resultobj = 0;
36062 wxWindow *arg1 = (wxWindow *) 0 ;
36063 wxFont result;
36064 void *argp1 = 0 ;
36065 int res1 = 0 ;
36066 PyObject *swig_obj[1] ;
36067
36068 if (!args) SWIG_fail;
36069 swig_obj[0] = args;
36070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36071 if (!SWIG_IsOK(res1)) {
36072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36073 }
36074 arg1 = reinterpret_cast< wxWindow * >(argp1);
36075 {
36076 PyThreadState* __tstate = wxPyBeginAllowThreads();
36077 result = (arg1)->GetFont();
36078 wxPyEndAllowThreads(__tstate);
36079 if (PyErr_Occurred()) SWIG_fail;
36080 }
36081 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36082 return resultobj;
36083 fail:
36084 return NULL;
36085 }
36086
36087
36088 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36089 PyObject *resultobj = 0;
36090 wxWindow *arg1 = (wxWindow *) 0 ;
36091 wxCaret *arg2 = (wxCaret *) 0 ;
36092 void *argp1 = 0 ;
36093 int res1 = 0 ;
36094 int res2 = 0 ;
36095 PyObject * obj0 = 0 ;
36096 PyObject * obj1 = 0 ;
36097 char * kwnames[] = {
36098 (char *) "self",(char *) "caret", NULL
36099 };
36100
36101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36103 if (!SWIG_IsOK(res1)) {
36104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36105 }
36106 arg1 = reinterpret_cast< wxWindow * >(argp1);
36107 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36108 if (!SWIG_IsOK(res2)) {
36109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36110 }
36111 {
36112 PyThreadState* __tstate = wxPyBeginAllowThreads();
36113 (arg1)->SetCaret(arg2);
36114 wxPyEndAllowThreads(__tstate);
36115 if (PyErr_Occurred()) SWIG_fail;
36116 }
36117 resultobj = SWIG_Py_Void();
36118 return resultobj;
36119 fail:
36120 return NULL;
36121 }
36122
36123
36124 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36125 PyObject *resultobj = 0;
36126 wxWindow *arg1 = (wxWindow *) 0 ;
36127 wxCaret *result = 0 ;
36128 void *argp1 = 0 ;
36129 int res1 = 0 ;
36130 PyObject *swig_obj[1] ;
36131
36132 if (!args) SWIG_fail;
36133 swig_obj[0] = args;
36134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36135 if (!SWIG_IsOK(res1)) {
36136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36137 }
36138 arg1 = reinterpret_cast< wxWindow * >(argp1);
36139 {
36140 PyThreadState* __tstate = wxPyBeginAllowThreads();
36141 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36142 wxPyEndAllowThreads(__tstate);
36143 if (PyErr_Occurred()) SWIG_fail;
36144 }
36145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36146 return resultobj;
36147 fail:
36148 return NULL;
36149 }
36150
36151
36152 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36153 PyObject *resultobj = 0;
36154 wxWindow *arg1 = (wxWindow *) 0 ;
36155 int result;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158 PyObject *swig_obj[1] ;
36159
36160 if (!args) SWIG_fail;
36161 swig_obj[0] = args;
36162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36163 if (!SWIG_IsOK(res1)) {
36164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36165 }
36166 arg1 = reinterpret_cast< wxWindow * >(argp1);
36167 {
36168 PyThreadState* __tstate = wxPyBeginAllowThreads();
36169 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36170 wxPyEndAllowThreads(__tstate);
36171 if (PyErr_Occurred()) SWIG_fail;
36172 }
36173 resultobj = SWIG_From_int(static_cast< int >(result));
36174 return resultobj;
36175 fail:
36176 return NULL;
36177 }
36178
36179
36180 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36181 PyObject *resultobj = 0;
36182 wxWindow *arg1 = (wxWindow *) 0 ;
36183 int result;
36184 void *argp1 = 0 ;
36185 int res1 = 0 ;
36186 PyObject *swig_obj[1] ;
36187
36188 if (!args) SWIG_fail;
36189 swig_obj[0] = args;
36190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36191 if (!SWIG_IsOK(res1)) {
36192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36193 }
36194 arg1 = reinterpret_cast< wxWindow * >(argp1);
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 resultobj = SWIG_From_int(static_cast< int >(result));
36202 return resultobj;
36203 fail:
36204 return NULL;
36205 }
36206
36207
36208 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36209 PyObject *resultobj = 0;
36210 wxWindow *arg1 = (wxWindow *) 0 ;
36211 wxString *arg2 = 0 ;
36212 int *arg3 = (int *) 0 ;
36213 int *arg4 = (int *) 0 ;
36214 void *argp1 = 0 ;
36215 int res1 = 0 ;
36216 bool temp2 = false ;
36217 int temp3 ;
36218 int res3 = SWIG_TMPOBJ ;
36219 int temp4 ;
36220 int res4 = SWIG_TMPOBJ ;
36221 PyObject * obj0 = 0 ;
36222 PyObject * obj1 = 0 ;
36223 char * kwnames[] = {
36224 (char *) "self",(char *) "string", NULL
36225 };
36226
36227 arg3 = &temp3;
36228 arg4 = &temp4;
36229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36233 }
36234 arg1 = reinterpret_cast< wxWindow * >(argp1);
36235 {
36236 arg2 = wxString_in_helper(obj1);
36237 if (arg2 == NULL) SWIG_fail;
36238 temp2 = true;
36239 }
36240 {
36241 PyThreadState* __tstate = wxPyBeginAllowThreads();
36242 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36243 wxPyEndAllowThreads(__tstate);
36244 if (PyErr_Occurred()) SWIG_fail;
36245 }
36246 resultobj = SWIG_Py_Void();
36247 if (SWIG_IsTmpObj(res3)) {
36248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36249 } else {
36250 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36252 }
36253 if (SWIG_IsTmpObj(res4)) {
36254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36255 } else {
36256 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36258 }
36259 {
36260 if (temp2)
36261 delete arg2;
36262 }
36263 return resultobj;
36264 fail:
36265 {
36266 if (temp2)
36267 delete arg2;
36268 }
36269 return NULL;
36270 }
36271
36272
36273 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36274 PyObject *resultobj = 0;
36275 wxWindow *arg1 = (wxWindow *) 0 ;
36276 wxString *arg2 = 0 ;
36277 int *arg3 = (int *) 0 ;
36278 int *arg4 = (int *) 0 ;
36279 int *arg5 = (int *) 0 ;
36280 int *arg6 = (int *) 0 ;
36281 wxFont *arg7 = (wxFont *) NULL ;
36282 void *argp1 = 0 ;
36283 int res1 = 0 ;
36284 bool temp2 = false ;
36285 int temp3 ;
36286 int res3 = SWIG_TMPOBJ ;
36287 int temp4 ;
36288 int res4 = SWIG_TMPOBJ ;
36289 int temp5 ;
36290 int res5 = SWIG_TMPOBJ ;
36291 int temp6 ;
36292 int res6 = SWIG_TMPOBJ ;
36293 void *argp7 = 0 ;
36294 int res7 = 0 ;
36295 PyObject * obj0 = 0 ;
36296 PyObject * obj1 = 0 ;
36297 PyObject * obj2 = 0 ;
36298 char * kwnames[] = {
36299 (char *) "self",(char *) "string",(char *) "font", NULL
36300 };
36301
36302 arg3 = &temp3;
36303 arg4 = &temp4;
36304 arg5 = &temp5;
36305 arg6 = &temp6;
36306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36308 if (!SWIG_IsOK(res1)) {
36309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36310 }
36311 arg1 = reinterpret_cast< wxWindow * >(argp1);
36312 {
36313 arg2 = wxString_in_helper(obj1);
36314 if (arg2 == NULL) SWIG_fail;
36315 temp2 = true;
36316 }
36317 if (obj2) {
36318 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36319 if (!SWIG_IsOK(res7)) {
36320 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36321 }
36322 arg7 = reinterpret_cast< wxFont * >(argp7);
36323 }
36324 {
36325 PyThreadState* __tstate = wxPyBeginAllowThreads();
36326 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36327 wxPyEndAllowThreads(__tstate);
36328 if (PyErr_Occurred()) SWIG_fail;
36329 }
36330 resultobj = SWIG_Py_Void();
36331 if (SWIG_IsTmpObj(res3)) {
36332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36333 } else {
36334 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36336 }
36337 if (SWIG_IsTmpObj(res4)) {
36338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36339 } else {
36340 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36342 }
36343 if (SWIG_IsTmpObj(res5)) {
36344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36345 } else {
36346 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36348 }
36349 if (SWIG_IsTmpObj(res6)) {
36350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36351 } else {
36352 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36354 }
36355 {
36356 if (temp2)
36357 delete arg2;
36358 }
36359 return resultobj;
36360 fail:
36361 {
36362 if (temp2)
36363 delete arg2;
36364 }
36365 return NULL;
36366 }
36367
36368
36369 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36370 PyObject *resultobj = 0;
36371 wxWindow *arg1 = (wxWindow *) 0 ;
36372 int *arg2 = (int *) 0 ;
36373 int *arg3 = (int *) 0 ;
36374 void *argp1 = 0 ;
36375 int res1 = 0 ;
36376 int temp2 ;
36377 int res2 = 0 ;
36378 int temp3 ;
36379 int res3 = 0 ;
36380 PyObject * obj0 = 0 ;
36381 PyObject * obj1 = 0 ;
36382 PyObject * obj2 = 0 ;
36383 char * kwnames[] = {
36384 (char *) "self",(char *) "x",(char *) "y", NULL
36385 };
36386
36387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36389 if (!SWIG_IsOK(res1)) {
36390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36391 }
36392 arg1 = reinterpret_cast< wxWindow * >(argp1);
36393 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36394 int val;
36395 int ecode = SWIG_AsVal_int(obj1, &val);
36396 if (!SWIG_IsOK(ecode)) {
36397 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36398 }
36399 temp2 = static_cast< int >(val);
36400 arg2 = &temp2;
36401 res2 = SWIG_AddTmpMask(ecode);
36402 }
36403 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36404 int val;
36405 int ecode = SWIG_AsVal_int(obj2, &val);
36406 if (!SWIG_IsOK(ecode)) {
36407 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36408 }
36409 temp3 = static_cast< int >(val);
36410 arg3 = &temp3;
36411 res3 = SWIG_AddTmpMask(ecode);
36412 }
36413 {
36414 PyThreadState* __tstate = wxPyBeginAllowThreads();
36415 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36416 wxPyEndAllowThreads(__tstate);
36417 if (PyErr_Occurred()) SWIG_fail;
36418 }
36419 resultobj = SWIG_Py_Void();
36420 if (SWIG_IsTmpObj(res2)) {
36421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36422 } else {
36423 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36425 }
36426 if (SWIG_IsTmpObj(res3)) {
36427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36428 } else {
36429 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36431 }
36432 return resultobj;
36433 fail:
36434 return NULL;
36435 }
36436
36437
36438 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36439 PyObject *resultobj = 0;
36440 wxWindow *arg1 = (wxWindow *) 0 ;
36441 int *arg2 = (int *) 0 ;
36442 int *arg3 = (int *) 0 ;
36443 void *argp1 = 0 ;
36444 int res1 = 0 ;
36445 int temp2 ;
36446 int res2 = 0 ;
36447 int temp3 ;
36448 int res3 = 0 ;
36449 PyObject * obj0 = 0 ;
36450 PyObject * obj1 = 0 ;
36451 PyObject * obj2 = 0 ;
36452 char * kwnames[] = {
36453 (char *) "self",(char *) "x",(char *) "y", NULL
36454 };
36455
36456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36458 if (!SWIG_IsOK(res1)) {
36459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36460 }
36461 arg1 = reinterpret_cast< wxWindow * >(argp1);
36462 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36463 int val;
36464 int ecode = SWIG_AsVal_int(obj1, &val);
36465 if (!SWIG_IsOK(ecode)) {
36466 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36467 }
36468 temp2 = static_cast< int >(val);
36469 arg2 = &temp2;
36470 res2 = SWIG_AddTmpMask(ecode);
36471 }
36472 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36473 int val;
36474 int ecode = SWIG_AsVal_int(obj2, &val);
36475 if (!SWIG_IsOK(ecode)) {
36476 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36477 }
36478 temp3 = static_cast< int >(val);
36479 arg3 = &temp3;
36480 res3 = SWIG_AddTmpMask(ecode);
36481 }
36482 {
36483 PyThreadState* __tstate = wxPyBeginAllowThreads();
36484 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36485 wxPyEndAllowThreads(__tstate);
36486 if (PyErr_Occurred()) SWIG_fail;
36487 }
36488 resultobj = SWIG_Py_Void();
36489 if (SWIG_IsTmpObj(res2)) {
36490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36491 } else {
36492 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36494 }
36495 if (SWIG_IsTmpObj(res3)) {
36496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36497 } else {
36498 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36500 }
36501 return resultobj;
36502 fail:
36503 return NULL;
36504 }
36505
36506
36507 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36508 PyObject *resultobj = 0;
36509 wxWindow *arg1 = (wxWindow *) 0 ;
36510 wxPoint *arg2 = 0 ;
36511 wxPoint result;
36512 void *argp1 = 0 ;
36513 int res1 = 0 ;
36514 wxPoint temp2 ;
36515 PyObject * obj0 = 0 ;
36516 PyObject * obj1 = 0 ;
36517 char * kwnames[] = {
36518 (char *) "self",(char *) "pt", NULL
36519 };
36520
36521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36523 if (!SWIG_IsOK(res1)) {
36524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36525 }
36526 arg1 = reinterpret_cast< wxWindow * >(argp1);
36527 {
36528 arg2 = &temp2;
36529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36530 }
36531 {
36532 PyThreadState* __tstate = wxPyBeginAllowThreads();
36533 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36534 wxPyEndAllowThreads(__tstate);
36535 if (PyErr_Occurred()) SWIG_fail;
36536 }
36537 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36538 return resultobj;
36539 fail:
36540 return NULL;
36541 }
36542
36543
36544 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36545 PyObject *resultobj = 0;
36546 wxWindow *arg1 = (wxWindow *) 0 ;
36547 wxPoint *arg2 = 0 ;
36548 wxPoint result;
36549 void *argp1 = 0 ;
36550 int res1 = 0 ;
36551 wxPoint temp2 ;
36552 PyObject * obj0 = 0 ;
36553 PyObject * obj1 = 0 ;
36554 char * kwnames[] = {
36555 (char *) "self",(char *) "pt", NULL
36556 };
36557
36558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 {
36565 arg2 = &temp2;
36566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36567 }
36568 {
36569 PyThreadState* __tstate = wxPyBeginAllowThreads();
36570 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36582 PyObject *resultobj = 0;
36583 wxWindow *arg1 = (wxWindow *) 0 ;
36584 int arg2 ;
36585 int arg3 ;
36586 wxHitTest result;
36587 void *argp1 = 0 ;
36588 int res1 = 0 ;
36589 int val2 ;
36590 int ecode2 = 0 ;
36591 int val3 ;
36592 int ecode3 = 0 ;
36593 PyObject * obj0 = 0 ;
36594 PyObject * obj1 = 0 ;
36595 PyObject * obj2 = 0 ;
36596 char * kwnames[] = {
36597 (char *) "self",(char *) "x",(char *) "y", NULL
36598 };
36599
36600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36602 if (!SWIG_IsOK(res1)) {
36603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36604 }
36605 arg1 = reinterpret_cast< wxWindow * >(argp1);
36606 ecode2 = SWIG_AsVal_int(obj1, &val2);
36607 if (!SWIG_IsOK(ecode2)) {
36608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36609 }
36610 arg2 = static_cast< int >(val2);
36611 ecode3 = SWIG_AsVal_int(obj2, &val3);
36612 if (!SWIG_IsOK(ecode3)) {
36613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36614 }
36615 arg3 = static_cast< int >(val3);
36616 {
36617 PyThreadState* __tstate = wxPyBeginAllowThreads();
36618 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36619 wxPyEndAllowThreads(__tstate);
36620 if (PyErr_Occurred()) SWIG_fail;
36621 }
36622 resultobj = SWIG_From_int(static_cast< int >(result));
36623 return resultobj;
36624 fail:
36625 return NULL;
36626 }
36627
36628
36629 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36630 PyObject *resultobj = 0;
36631 wxWindow *arg1 = (wxWindow *) 0 ;
36632 wxPoint *arg2 = 0 ;
36633 wxHitTest result;
36634 void *argp1 = 0 ;
36635 int res1 = 0 ;
36636 wxPoint temp2 ;
36637 PyObject * obj0 = 0 ;
36638 PyObject * obj1 = 0 ;
36639 char * kwnames[] = {
36640 (char *) "self",(char *) "pt", NULL
36641 };
36642
36643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36645 if (!SWIG_IsOK(res1)) {
36646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36647 }
36648 arg1 = reinterpret_cast< wxWindow * >(argp1);
36649 {
36650 arg2 = &temp2;
36651 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36652 }
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 resultobj = SWIG_From_int(static_cast< int >(result));
36660 return resultobj;
36661 fail:
36662 return NULL;
36663 }
36664
36665
36666 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36667 PyObject *resultobj = 0;
36668 wxWindow *arg1 = (wxWindow *) 0 ;
36669 long arg2 ;
36670 wxBorder result;
36671 void *argp1 = 0 ;
36672 int res1 = 0 ;
36673 long val2 ;
36674 int ecode2 = 0 ;
36675
36676 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36678 if (!SWIG_IsOK(res1)) {
36679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36680 }
36681 arg1 = reinterpret_cast< wxWindow * >(argp1);
36682 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36683 if (!SWIG_IsOK(ecode2)) {
36684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36685 }
36686 arg2 = static_cast< long >(val2);
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36690 wxPyEndAllowThreads(__tstate);
36691 if (PyErr_Occurred()) SWIG_fail;
36692 }
36693 resultobj = SWIG_From_int(static_cast< int >(result));
36694 return resultobj;
36695 fail:
36696 return NULL;
36697 }
36698
36699
36700 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36701 PyObject *resultobj = 0;
36702 wxWindow *arg1 = (wxWindow *) 0 ;
36703 wxBorder result;
36704 void *argp1 = 0 ;
36705 int res1 = 0 ;
36706
36707 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36709 if (!SWIG_IsOK(res1)) {
36710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36711 }
36712 arg1 = reinterpret_cast< wxWindow * >(argp1);
36713 {
36714 PyThreadState* __tstate = wxPyBeginAllowThreads();
36715 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36716 wxPyEndAllowThreads(__tstate);
36717 if (PyErr_Occurred()) SWIG_fail;
36718 }
36719 resultobj = SWIG_From_int(static_cast< int >(result));
36720 return resultobj;
36721 fail:
36722 return NULL;
36723 }
36724
36725
36726 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36727 int argc;
36728 PyObject *argv[3];
36729
36730 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36731 --argc;
36732 if (argc == 1) {
36733 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36734 }
36735 if (argc == 2) {
36736 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36737 }
36738
36739 fail:
36740 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36741 return NULL;
36742 }
36743
36744
36745 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36746 PyObject *resultobj = 0;
36747 wxWindow *arg1 = (wxWindow *) 0 ;
36748 long arg2 = (long) wxUPDATE_UI_NONE ;
36749 void *argp1 = 0 ;
36750 int res1 = 0 ;
36751 long val2 ;
36752 int ecode2 = 0 ;
36753 PyObject * obj0 = 0 ;
36754 PyObject * obj1 = 0 ;
36755 char * kwnames[] = {
36756 (char *) "self",(char *) "flags", NULL
36757 };
36758
36759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36761 if (!SWIG_IsOK(res1)) {
36762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36763 }
36764 arg1 = reinterpret_cast< wxWindow * >(argp1);
36765 if (obj1) {
36766 ecode2 = SWIG_AsVal_long(obj1, &val2);
36767 if (!SWIG_IsOK(ecode2)) {
36768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36769 }
36770 arg2 = static_cast< long >(val2);
36771 }
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 (arg1)->UpdateWindowUI(arg2);
36775 wxPyEndAllowThreads(__tstate);
36776 if (PyErr_Occurred()) SWIG_fail;
36777 }
36778 resultobj = SWIG_Py_Void();
36779 return resultobj;
36780 fail:
36781 return NULL;
36782 }
36783
36784
36785 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36786 PyObject *resultobj = 0;
36787 wxWindow *arg1 = (wxWindow *) 0 ;
36788 wxMenu *arg2 = (wxMenu *) 0 ;
36789 int arg3 = (int) -1 ;
36790 int arg4 = (int) -1 ;
36791 bool result;
36792 void *argp1 = 0 ;
36793 int res1 = 0 ;
36794 void *argp2 = 0 ;
36795 int res2 = 0 ;
36796 int val3 ;
36797 int ecode3 = 0 ;
36798 int val4 ;
36799 int ecode4 = 0 ;
36800 PyObject * obj0 = 0 ;
36801 PyObject * obj1 = 0 ;
36802 PyObject * obj2 = 0 ;
36803 PyObject * obj3 = 0 ;
36804 char * kwnames[] = {
36805 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36806 };
36807
36808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36810 if (!SWIG_IsOK(res1)) {
36811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36812 }
36813 arg1 = reinterpret_cast< wxWindow * >(argp1);
36814 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36815 if (!SWIG_IsOK(res2)) {
36816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36817 }
36818 arg2 = reinterpret_cast< wxMenu * >(argp2);
36819 if (obj2) {
36820 ecode3 = SWIG_AsVal_int(obj2, &val3);
36821 if (!SWIG_IsOK(ecode3)) {
36822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36823 }
36824 arg3 = static_cast< int >(val3);
36825 }
36826 if (obj3) {
36827 ecode4 = SWIG_AsVal_int(obj3, &val4);
36828 if (!SWIG_IsOK(ecode4)) {
36829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36830 }
36831 arg4 = static_cast< int >(val4);
36832 }
36833 {
36834 PyThreadState* __tstate = wxPyBeginAllowThreads();
36835 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36836 wxPyEndAllowThreads(__tstate);
36837 if (PyErr_Occurred()) SWIG_fail;
36838 }
36839 {
36840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36841 }
36842 return resultobj;
36843 fail:
36844 return NULL;
36845 }
36846
36847
36848 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36849 PyObject *resultobj = 0;
36850 wxWindow *arg1 = (wxWindow *) 0 ;
36851 wxMenu *arg2 = (wxMenu *) 0 ;
36852 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36853 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36854 bool result;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 void *argp2 = 0 ;
36858 int res2 = 0 ;
36859 wxPoint temp3 ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 PyObject * obj2 = 0 ;
36863 char * kwnames[] = {
36864 (char *) "self",(char *) "menu",(char *) "pos", NULL
36865 };
36866
36867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36869 if (!SWIG_IsOK(res1)) {
36870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36871 }
36872 arg1 = reinterpret_cast< wxWindow * >(argp1);
36873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36874 if (!SWIG_IsOK(res2)) {
36875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36876 }
36877 arg2 = reinterpret_cast< wxMenu * >(argp2);
36878 if (obj2) {
36879 {
36880 arg3 = &temp3;
36881 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36882 }
36883 }
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36887 wxPyEndAllowThreads(__tstate);
36888 if (PyErr_Occurred()) SWIG_fail;
36889 }
36890 {
36891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36892 }
36893 return resultobj;
36894 fail:
36895 return NULL;
36896 }
36897
36898
36899 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36900 PyObject *resultobj = 0;
36901 wxWindow *arg1 = (wxWindow *) 0 ;
36902 bool result;
36903 void *argp1 = 0 ;
36904 int res1 = 0 ;
36905 PyObject *swig_obj[1] ;
36906
36907 if (!args) SWIG_fail;
36908 swig_obj[0] = args;
36909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 {
36921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36922 }
36923 return resultobj;
36924 fail:
36925 return NULL;
36926 }
36927
36928
36929 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36930 PyObject *resultobj = 0;
36931 wxWindow *arg1 = (wxWindow *) 0 ;
36932 long result;
36933 void *argp1 = 0 ;
36934 int res1 = 0 ;
36935 PyObject *swig_obj[1] ;
36936
36937 if (!args) SWIG_fail;
36938 swig_obj[0] = args;
36939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36940 if (!SWIG_IsOK(res1)) {
36941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36942 }
36943 arg1 = reinterpret_cast< wxWindow * >(argp1);
36944 {
36945 PyThreadState* __tstate = wxPyBeginAllowThreads();
36946 result = (long)wxWindow_GetHandle(arg1);
36947 wxPyEndAllowThreads(__tstate);
36948 if (PyErr_Occurred()) SWIG_fail;
36949 }
36950 resultobj = SWIG_From_long(static_cast< long >(result));
36951 return resultobj;
36952 fail:
36953 return NULL;
36954 }
36955
36956
36957 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36958 PyObject *resultobj = 0;
36959 wxWindow *arg1 = (wxWindow *) 0 ;
36960 long arg2 ;
36961 void *argp1 = 0 ;
36962 int res1 = 0 ;
36963 long val2 ;
36964 int ecode2 = 0 ;
36965 PyObject * obj0 = 0 ;
36966 PyObject * obj1 = 0 ;
36967 char * kwnames[] = {
36968 (char *) "self",(char *) "handle", NULL
36969 };
36970
36971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36973 if (!SWIG_IsOK(res1)) {
36974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36975 }
36976 arg1 = reinterpret_cast< wxWindow * >(argp1);
36977 ecode2 = SWIG_AsVal_long(obj1, &val2);
36978 if (!SWIG_IsOK(ecode2)) {
36979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36980 }
36981 arg2 = static_cast< long >(val2);
36982 {
36983 PyThreadState* __tstate = wxPyBeginAllowThreads();
36984 wxWindow_AssociateHandle(arg1,arg2);
36985 wxPyEndAllowThreads(__tstate);
36986 if (PyErr_Occurred()) SWIG_fail;
36987 }
36988 resultobj = SWIG_Py_Void();
36989 return resultobj;
36990 fail:
36991 return NULL;
36992 }
36993
36994
36995 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36996 PyObject *resultobj = 0;
36997 wxWindow *arg1 = (wxWindow *) 0 ;
36998 void *argp1 = 0 ;
36999 int res1 = 0 ;
37000 PyObject *swig_obj[1] ;
37001
37002 if (!args) SWIG_fail;
37003 swig_obj[0] = args;
37004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37005 if (!SWIG_IsOK(res1)) {
37006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37007 }
37008 arg1 = reinterpret_cast< wxWindow * >(argp1);
37009 {
37010 PyThreadState* __tstate = wxPyBeginAllowThreads();
37011 (arg1)->DissociateHandle();
37012 wxPyEndAllowThreads(__tstate);
37013 if (PyErr_Occurred()) SWIG_fail;
37014 }
37015 resultobj = SWIG_Py_Void();
37016 return resultobj;
37017 fail:
37018 return NULL;
37019 }
37020
37021
37022 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37023 PyObject *resultobj = 0;
37024 wxWindow *arg1 = (wxWindow *) 0 ;
37025 wxPaintEvent *arg2 = 0 ;
37026 void *argp1 = 0 ;
37027 int res1 = 0 ;
37028 void *argp2 = 0 ;
37029 int res2 = 0 ;
37030 PyObject * obj0 = 0 ;
37031 PyObject * obj1 = 0 ;
37032 char * kwnames[] = {
37033 (char *) "self",(char *) "event", NULL
37034 };
37035
37036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
37037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37038 if (!SWIG_IsOK(res1)) {
37039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
37040 }
37041 arg1 = reinterpret_cast< wxWindow * >(argp1);
37042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
37043 if (!SWIG_IsOK(res2)) {
37044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37045 }
37046 if (!argp2) {
37047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37048 }
37049 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
37050 {
37051 PyThreadState* __tstate = wxPyBeginAllowThreads();
37052 (arg1)->OnPaint(*arg2);
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 resultobj = SWIG_Py_Void();
37057 return resultobj;
37058 fail:
37059 return NULL;
37060 }
37061
37062
37063 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37064 PyObject *resultobj = 0;
37065 wxWindow *arg1 = (wxWindow *) 0 ;
37066 int arg2 ;
37067 bool result;
37068 void *argp1 = 0 ;
37069 int res1 = 0 ;
37070 int val2 ;
37071 int ecode2 = 0 ;
37072 PyObject * obj0 = 0 ;
37073 PyObject * obj1 = 0 ;
37074 char * kwnames[] = {
37075 (char *) "self",(char *) "orient", NULL
37076 };
37077
37078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37080 if (!SWIG_IsOK(res1)) {
37081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37082 }
37083 arg1 = reinterpret_cast< wxWindow * >(argp1);
37084 ecode2 = SWIG_AsVal_int(obj1, &val2);
37085 if (!SWIG_IsOK(ecode2)) {
37086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37087 }
37088 arg2 = static_cast< int >(val2);
37089 {
37090 PyThreadState* __tstate = wxPyBeginAllowThreads();
37091 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37092 wxPyEndAllowThreads(__tstate);
37093 if (PyErr_Occurred()) SWIG_fail;
37094 }
37095 {
37096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37097 }
37098 return resultobj;
37099 fail:
37100 return NULL;
37101 }
37102
37103
37104 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37105 PyObject *resultobj = 0;
37106 wxWindow *arg1 = (wxWindow *) 0 ;
37107 int arg2 ;
37108 int arg3 ;
37109 int arg4 ;
37110 int arg5 ;
37111 bool arg6 = (bool) true ;
37112 void *argp1 = 0 ;
37113 int res1 = 0 ;
37114 int val2 ;
37115 int ecode2 = 0 ;
37116 int val3 ;
37117 int ecode3 = 0 ;
37118 int val4 ;
37119 int ecode4 = 0 ;
37120 int val5 ;
37121 int ecode5 = 0 ;
37122 bool val6 ;
37123 int ecode6 = 0 ;
37124 PyObject * obj0 = 0 ;
37125 PyObject * obj1 = 0 ;
37126 PyObject * obj2 = 0 ;
37127 PyObject * obj3 = 0 ;
37128 PyObject * obj4 = 0 ;
37129 PyObject * obj5 = 0 ;
37130 char * kwnames[] = {
37131 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37132 };
37133
37134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37136 if (!SWIG_IsOK(res1)) {
37137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37138 }
37139 arg1 = reinterpret_cast< wxWindow * >(argp1);
37140 ecode2 = SWIG_AsVal_int(obj1, &val2);
37141 if (!SWIG_IsOK(ecode2)) {
37142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37143 }
37144 arg2 = static_cast< int >(val2);
37145 ecode3 = SWIG_AsVal_int(obj2, &val3);
37146 if (!SWIG_IsOK(ecode3)) {
37147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37148 }
37149 arg3 = static_cast< int >(val3);
37150 ecode4 = SWIG_AsVal_int(obj3, &val4);
37151 if (!SWIG_IsOK(ecode4)) {
37152 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37153 }
37154 arg4 = static_cast< int >(val4);
37155 ecode5 = SWIG_AsVal_int(obj4, &val5);
37156 if (!SWIG_IsOK(ecode5)) {
37157 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37158 }
37159 arg5 = static_cast< int >(val5);
37160 if (obj5) {
37161 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37162 if (!SWIG_IsOK(ecode6)) {
37163 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37164 }
37165 arg6 = static_cast< bool >(val6);
37166 }
37167 {
37168 PyThreadState* __tstate = wxPyBeginAllowThreads();
37169 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37170 wxPyEndAllowThreads(__tstate);
37171 if (PyErr_Occurred()) SWIG_fail;
37172 }
37173 resultobj = SWIG_Py_Void();
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37181 PyObject *resultobj = 0;
37182 wxWindow *arg1 = (wxWindow *) 0 ;
37183 int arg2 ;
37184 int arg3 ;
37185 bool arg4 = (bool) true ;
37186 void *argp1 = 0 ;
37187 int res1 = 0 ;
37188 int val2 ;
37189 int ecode2 = 0 ;
37190 int val3 ;
37191 int ecode3 = 0 ;
37192 bool val4 ;
37193 int ecode4 = 0 ;
37194 PyObject * obj0 = 0 ;
37195 PyObject * obj1 = 0 ;
37196 PyObject * obj2 = 0 ;
37197 PyObject * obj3 = 0 ;
37198 char * kwnames[] = {
37199 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37200 };
37201
37202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37204 if (!SWIG_IsOK(res1)) {
37205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37206 }
37207 arg1 = reinterpret_cast< wxWindow * >(argp1);
37208 ecode2 = SWIG_AsVal_int(obj1, &val2);
37209 if (!SWIG_IsOK(ecode2)) {
37210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37211 }
37212 arg2 = static_cast< int >(val2);
37213 ecode3 = SWIG_AsVal_int(obj2, &val3);
37214 if (!SWIG_IsOK(ecode3)) {
37215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37216 }
37217 arg3 = static_cast< int >(val3);
37218 if (obj3) {
37219 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37220 if (!SWIG_IsOK(ecode4)) {
37221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37222 }
37223 arg4 = static_cast< bool >(val4);
37224 }
37225 {
37226 PyThreadState* __tstate = wxPyBeginAllowThreads();
37227 (arg1)->SetScrollPos(arg2,arg3,arg4);
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 resultobj = SWIG_Py_Void();
37232 return resultobj;
37233 fail:
37234 return NULL;
37235 }
37236
37237
37238 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37239 PyObject *resultobj = 0;
37240 wxWindow *arg1 = (wxWindow *) 0 ;
37241 int arg2 ;
37242 int result;
37243 void *argp1 = 0 ;
37244 int res1 = 0 ;
37245 int val2 ;
37246 int ecode2 = 0 ;
37247 PyObject * obj0 = 0 ;
37248 PyObject * obj1 = 0 ;
37249 char * kwnames[] = {
37250 (char *) "self",(char *) "orientation", NULL
37251 };
37252
37253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37255 if (!SWIG_IsOK(res1)) {
37256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37257 }
37258 arg1 = reinterpret_cast< wxWindow * >(argp1);
37259 ecode2 = SWIG_AsVal_int(obj1, &val2);
37260 if (!SWIG_IsOK(ecode2)) {
37261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37262 }
37263 arg2 = static_cast< int >(val2);
37264 {
37265 PyThreadState* __tstate = wxPyBeginAllowThreads();
37266 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37267 wxPyEndAllowThreads(__tstate);
37268 if (PyErr_Occurred()) SWIG_fail;
37269 }
37270 resultobj = SWIG_From_int(static_cast< int >(result));
37271 return resultobj;
37272 fail:
37273 return NULL;
37274 }
37275
37276
37277 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37278 PyObject *resultobj = 0;
37279 wxWindow *arg1 = (wxWindow *) 0 ;
37280 int arg2 ;
37281 int result;
37282 void *argp1 = 0 ;
37283 int res1 = 0 ;
37284 int val2 ;
37285 int ecode2 = 0 ;
37286 PyObject * obj0 = 0 ;
37287 PyObject * obj1 = 0 ;
37288 char * kwnames[] = {
37289 (char *) "self",(char *) "orientation", NULL
37290 };
37291
37292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37294 if (!SWIG_IsOK(res1)) {
37295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37296 }
37297 arg1 = reinterpret_cast< wxWindow * >(argp1);
37298 ecode2 = SWIG_AsVal_int(obj1, &val2);
37299 if (!SWIG_IsOK(ecode2)) {
37300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37301 }
37302 arg2 = static_cast< int >(val2);
37303 {
37304 PyThreadState* __tstate = wxPyBeginAllowThreads();
37305 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37306 wxPyEndAllowThreads(__tstate);
37307 if (PyErr_Occurred()) SWIG_fail;
37308 }
37309 resultobj = SWIG_From_int(static_cast< int >(result));
37310 return resultobj;
37311 fail:
37312 return NULL;
37313 }
37314
37315
37316 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37317 PyObject *resultobj = 0;
37318 wxWindow *arg1 = (wxWindow *) 0 ;
37319 int arg2 ;
37320 int result;
37321 void *argp1 = 0 ;
37322 int res1 = 0 ;
37323 int val2 ;
37324 int ecode2 = 0 ;
37325 PyObject * obj0 = 0 ;
37326 PyObject * obj1 = 0 ;
37327 char * kwnames[] = {
37328 (char *) "self",(char *) "orientation", NULL
37329 };
37330
37331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37333 if (!SWIG_IsOK(res1)) {
37334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37335 }
37336 arg1 = reinterpret_cast< wxWindow * >(argp1);
37337 ecode2 = SWIG_AsVal_int(obj1, &val2);
37338 if (!SWIG_IsOK(ecode2)) {
37339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37340 }
37341 arg2 = static_cast< int >(val2);
37342 {
37343 PyThreadState* __tstate = wxPyBeginAllowThreads();
37344 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37345 wxPyEndAllowThreads(__tstate);
37346 if (PyErr_Occurred()) SWIG_fail;
37347 }
37348 resultobj = SWIG_From_int(static_cast< int >(result));
37349 return resultobj;
37350 fail:
37351 return NULL;
37352 }
37353
37354
37355 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37356 PyObject *resultobj = 0;
37357 wxWindow *arg1 = (wxWindow *) 0 ;
37358 int arg2 ;
37359 int arg3 ;
37360 wxRect *arg4 = (wxRect *) NULL ;
37361 void *argp1 = 0 ;
37362 int res1 = 0 ;
37363 int val2 ;
37364 int ecode2 = 0 ;
37365 int val3 ;
37366 int ecode3 = 0 ;
37367 void *argp4 = 0 ;
37368 int res4 = 0 ;
37369 PyObject * obj0 = 0 ;
37370 PyObject * obj1 = 0 ;
37371 PyObject * obj2 = 0 ;
37372 PyObject * obj3 = 0 ;
37373 char * kwnames[] = {
37374 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37375 };
37376
37377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37379 if (!SWIG_IsOK(res1)) {
37380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37381 }
37382 arg1 = reinterpret_cast< wxWindow * >(argp1);
37383 ecode2 = SWIG_AsVal_int(obj1, &val2);
37384 if (!SWIG_IsOK(ecode2)) {
37385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37386 }
37387 arg2 = static_cast< int >(val2);
37388 ecode3 = SWIG_AsVal_int(obj2, &val3);
37389 if (!SWIG_IsOK(ecode3)) {
37390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37391 }
37392 arg3 = static_cast< int >(val3);
37393 if (obj3) {
37394 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37395 if (!SWIG_IsOK(res4)) {
37396 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37397 }
37398 arg4 = reinterpret_cast< wxRect * >(argp4);
37399 }
37400 {
37401 PyThreadState* __tstate = wxPyBeginAllowThreads();
37402 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37403 wxPyEndAllowThreads(__tstate);
37404 if (PyErr_Occurred()) SWIG_fail;
37405 }
37406 resultobj = SWIG_Py_Void();
37407 return resultobj;
37408 fail:
37409 return NULL;
37410 }
37411
37412
37413 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37414 PyObject *resultobj = 0;
37415 wxWindow *arg1 = (wxWindow *) 0 ;
37416 int arg2 ;
37417 bool result;
37418 void *argp1 = 0 ;
37419 int res1 = 0 ;
37420 int val2 ;
37421 int ecode2 = 0 ;
37422 PyObject * obj0 = 0 ;
37423 PyObject * obj1 = 0 ;
37424 char * kwnames[] = {
37425 (char *) "self",(char *) "lines", NULL
37426 };
37427
37428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37430 if (!SWIG_IsOK(res1)) {
37431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37432 }
37433 arg1 = reinterpret_cast< wxWindow * >(argp1);
37434 ecode2 = SWIG_AsVal_int(obj1, &val2);
37435 if (!SWIG_IsOK(ecode2)) {
37436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37437 }
37438 arg2 = static_cast< int >(val2);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 result = (bool)(arg1)->ScrollLines(arg2);
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 {
37446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37447 }
37448 return resultobj;
37449 fail:
37450 return NULL;
37451 }
37452
37453
37454 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37455 PyObject *resultobj = 0;
37456 wxWindow *arg1 = (wxWindow *) 0 ;
37457 int arg2 ;
37458 bool result;
37459 void *argp1 = 0 ;
37460 int res1 = 0 ;
37461 int val2 ;
37462 int ecode2 = 0 ;
37463 PyObject * obj0 = 0 ;
37464 PyObject * obj1 = 0 ;
37465 char * kwnames[] = {
37466 (char *) "self",(char *) "pages", NULL
37467 };
37468
37469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37471 if (!SWIG_IsOK(res1)) {
37472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37473 }
37474 arg1 = reinterpret_cast< wxWindow * >(argp1);
37475 ecode2 = SWIG_AsVal_int(obj1, &val2);
37476 if (!SWIG_IsOK(ecode2)) {
37477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37478 }
37479 arg2 = static_cast< int >(val2);
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 result = (bool)(arg1)->ScrollPages(arg2);
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 {
37487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37488 }
37489 return resultobj;
37490 fail:
37491 return NULL;
37492 }
37493
37494
37495 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37496 PyObject *resultobj = 0;
37497 wxWindow *arg1 = (wxWindow *) 0 ;
37498 bool result;
37499 void *argp1 = 0 ;
37500 int res1 = 0 ;
37501 PyObject *swig_obj[1] ;
37502
37503 if (!args) SWIG_fail;
37504 swig_obj[0] = args;
37505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37506 if (!SWIG_IsOK(res1)) {
37507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37508 }
37509 arg1 = reinterpret_cast< wxWindow * >(argp1);
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 result = (bool)(arg1)->LineUp();
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 {
37517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37518 }
37519 return resultobj;
37520 fail:
37521 return NULL;
37522 }
37523
37524
37525 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37526 PyObject *resultobj = 0;
37527 wxWindow *arg1 = (wxWindow *) 0 ;
37528 bool result;
37529 void *argp1 = 0 ;
37530 int res1 = 0 ;
37531 PyObject *swig_obj[1] ;
37532
37533 if (!args) SWIG_fail;
37534 swig_obj[0] = args;
37535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37536 if (!SWIG_IsOK(res1)) {
37537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37538 }
37539 arg1 = reinterpret_cast< wxWindow * >(argp1);
37540 {
37541 PyThreadState* __tstate = wxPyBeginAllowThreads();
37542 result = (bool)(arg1)->LineDown();
37543 wxPyEndAllowThreads(__tstate);
37544 if (PyErr_Occurred()) SWIG_fail;
37545 }
37546 {
37547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37548 }
37549 return resultobj;
37550 fail:
37551 return NULL;
37552 }
37553
37554
37555 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37556 PyObject *resultobj = 0;
37557 wxWindow *arg1 = (wxWindow *) 0 ;
37558 bool result;
37559 void *argp1 = 0 ;
37560 int res1 = 0 ;
37561 PyObject *swig_obj[1] ;
37562
37563 if (!args) SWIG_fail;
37564 swig_obj[0] = args;
37565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37566 if (!SWIG_IsOK(res1)) {
37567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37568 }
37569 arg1 = reinterpret_cast< wxWindow * >(argp1);
37570 {
37571 PyThreadState* __tstate = wxPyBeginAllowThreads();
37572 result = (bool)(arg1)->PageUp();
37573 wxPyEndAllowThreads(__tstate);
37574 if (PyErr_Occurred()) SWIG_fail;
37575 }
37576 {
37577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37578 }
37579 return resultobj;
37580 fail:
37581 return NULL;
37582 }
37583
37584
37585 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37586 PyObject *resultobj = 0;
37587 wxWindow *arg1 = (wxWindow *) 0 ;
37588 bool result;
37589 void *argp1 = 0 ;
37590 int res1 = 0 ;
37591 PyObject *swig_obj[1] ;
37592
37593 if (!args) SWIG_fail;
37594 swig_obj[0] = args;
37595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37596 if (!SWIG_IsOK(res1)) {
37597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37598 }
37599 arg1 = reinterpret_cast< wxWindow * >(argp1);
37600 {
37601 PyThreadState* __tstate = wxPyBeginAllowThreads();
37602 result = (bool)(arg1)->PageDown();
37603 wxPyEndAllowThreads(__tstate);
37604 if (PyErr_Occurred()) SWIG_fail;
37605 }
37606 {
37607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37608 }
37609 return resultobj;
37610 fail:
37611 return NULL;
37612 }
37613
37614
37615 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37616 PyObject *resultobj = 0;
37617 wxWindow *arg1 = (wxWindow *) 0 ;
37618 wxString *arg2 = 0 ;
37619 void *argp1 = 0 ;
37620 int res1 = 0 ;
37621 bool temp2 = false ;
37622 PyObject * obj0 = 0 ;
37623 PyObject * obj1 = 0 ;
37624 char * kwnames[] = {
37625 (char *) "self",(char *) "text", NULL
37626 };
37627
37628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37630 if (!SWIG_IsOK(res1)) {
37631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37632 }
37633 arg1 = reinterpret_cast< wxWindow * >(argp1);
37634 {
37635 arg2 = wxString_in_helper(obj1);
37636 if (arg2 == NULL) SWIG_fail;
37637 temp2 = true;
37638 }
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 (arg1)->SetHelpText((wxString const &)*arg2);
37642 wxPyEndAllowThreads(__tstate);
37643 if (PyErr_Occurred()) SWIG_fail;
37644 }
37645 resultobj = SWIG_Py_Void();
37646 {
37647 if (temp2)
37648 delete arg2;
37649 }
37650 return resultobj;
37651 fail:
37652 {
37653 if (temp2)
37654 delete arg2;
37655 }
37656 return NULL;
37657 }
37658
37659
37660 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj = 0;
37662 wxWindow *arg1 = (wxWindow *) 0 ;
37663 wxString *arg2 = 0 ;
37664 void *argp1 = 0 ;
37665 int res1 = 0 ;
37666 bool temp2 = false ;
37667 PyObject * obj0 = 0 ;
37668 PyObject * obj1 = 0 ;
37669 char * kwnames[] = {
37670 (char *) "self",(char *) "text", NULL
37671 };
37672
37673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37675 if (!SWIG_IsOK(res1)) {
37676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37677 }
37678 arg1 = reinterpret_cast< wxWindow * >(argp1);
37679 {
37680 arg2 = wxString_in_helper(obj1);
37681 if (arg2 == NULL) SWIG_fail;
37682 temp2 = true;
37683 }
37684 {
37685 PyThreadState* __tstate = wxPyBeginAllowThreads();
37686 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37687 wxPyEndAllowThreads(__tstate);
37688 if (PyErr_Occurred()) SWIG_fail;
37689 }
37690 resultobj = SWIG_Py_Void();
37691 {
37692 if (temp2)
37693 delete arg2;
37694 }
37695 return resultobj;
37696 fail:
37697 {
37698 if (temp2)
37699 delete arg2;
37700 }
37701 return NULL;
37702 }
37703
37704
37705 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37706 PyObject *resultobj = 0;
37707 wxWindow *arg1 = (wxWindow *) 0 ;
37708 wxPoint *arg2 = 0 ;
37709 wxHelpEvent::Origin arg3 ;
37710 wxString result;
37711 void *argp1 = 0 ;
37712 int res1 = 0 ;
37713 wxPoint temp2 ;
37714 void *argp3 ;
37715 int res3 = 0 ;
37716 PyObject * obj0 = 0 ;
37717 PyObject * obj1 = 0 ;
37718 PyObject * obj2 = 0 ;
37719 char * kwnames[] = {
37720 (char *) "self",(char *) "pt",(char *) "origin", NULL
37721 };
37722
37723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37725 if (!SWIG_IsOK(res1)) {
37726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37727 }
37728 arg1 = reinterpret_cast< wxWindow * >(argp1);
37729 {
37730 arg2 = &temp2;
37731 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37732 }
37733 {
37734 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37735 if (!SWIG_IsOK(res3)) {
37736 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37737 }
37738 if (!argp3) {
37739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37740 } else {
37741 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37742 arg3 = *temp;
37743 if (SWIG_IsNewObj(res3)) delete temp;
37744 }
37745 }
37746 {
37747 PyThreadState* __tstate = wxPyBeginAllowThreads();
37748 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37749 wxPyEndAllowThreads(__tstate);
37750 if (PyErr_Occurred()) SWIG_fail;
37751 }
37752 {
37753 #if wxUSE_UNICODE
37754 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37755 #else
37756 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37757 #endif
37758 }
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37766 PyObject *resultobj = 0;
37767 wxWindow *arg1 = (wxWindow *) 0 ;
37768 wxString result;
37769 void *argp1 = 0 ;
37770 int res1 = 0 ;
37771 PyObject *swig_obj[1] ;
37772
37773 if (!args) SWIG_fail;
37774 swig_obj[0] = args;
37775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37776 if (!SWIG_IsOK(res1)) {
37777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37778 }
37779 arg1 = reinterpret_cast< wxWindow * >(argp1);
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 result = ((wxWindow const *)arg1)->GetHelpText();
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 {
37787 #if wxUSE_UNICODE
37788 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37789 #else
37790 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37791 #endif
37792 }
37793 return resultobj;
37794 fail:
37795 return NULL;
37796 }
37797
37798
37799 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37800 PyObject *resultobj = 0;
37801 wxWindow *arg1 = (wxWindow *) 0 ;
37802 wxString *arg2 = 0 ;
37803 void *argp1 = 0 ;
37804 int res1 = 0 ;
37805 bool temp2 = false ;
37806 PyObject * obj0 = 0 ;
37807 PyObject * obj1 = 0 ;
37808 char * kwnames[] = {
37809 (char *) "self",(char *) "tip", NULL
37810 };
37811
37812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37814 if (!SWIG_IsOK(res1)) {
37815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37816 }
37817 arg1 = reinterpret_cast< wxWindow * >(argp1);
37818 {
37819 arg2 = wxString_in_helper(obj1);
37820 if (arg2 == NULL) SWIG_fail;
37821 temp2 = true;
37822 }
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 (arg1)->SetToolTip((wxString const &)*arg2);
37826 wxPyEndAllowThreads(__tstate);
37827 if (PyErr_Occurred()) SWIG_fail;
37828 }
37829 resultobj = SWIG_Py_Void();
37830 {
37831 if (temp2)
37832 delete arg2;
37833 }
37834 return resultobj;
37835 fail:
37836 {
37837 if (temp2)
37838 delete arg2;
37839 }
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj = 0;
37846 wxWindow *arg1 = (wxWindow *) 0 ;
37847 wxToolTip *arg2 = (wxToolTip *) 0 ;
37848 void *argp1 = 0 ;
37849 int res1 = 0 ;
37850 int res2 = 0 ;
37851 PyObject * obj0 = 0 ;
37852 PyObject * obj1 = 0 ;
37853 char * kwnames[] = {
37854 (char *) "self",(char *) "tip", NULL
37855 };
37856
37857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37859 if (!SWIG_IsOK(res1)) {
37860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37861 }
37862 arg1 = reinterpret_cast< wxWindow * >(argp1);
37863 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37864 if (!SWIG_IsOK(res2)) {
37865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37866 }
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 (arg1)->SetToolTip(arg2);
37870 wxPyEndAllowThreads(__tstate);
37871 if (PyErr_Occurred()) SWIG_fail;
37872 }
37873 resultobj = SWIG_Py_Void();
37874 return resultobj;
37875 fail:
37876 return NULL;
37877 }
37878
37879
37880 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37881 PyObject *resultobj = 0;
37882 wxWindow *arg1 = (wxWindow *) 0 ;
37883 wxToolTip *result = 0 ;
37884 void *argp1 = 0 ;
37885 int res1 = 0 ;
37886 PyObject *swig_obj[1] ;
37887
37888 if (!args) SWIG_fail;
37889 swig_obj[0] = args;
37890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37891 if (!SWIG_IsOK(res1)) {
37892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37893 }
37894 arg1 = reinterpret_cast< wxWindow * >(argp1);
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37898 wxPyEndAllowThreads(__tstate);
37899 if (PyErr_Occurred()) SWIG_fail;
37900 }
37901 {
37902 resultobj = wxPyMake_wxObject(result, (bool)0);
37903 }
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37911 PyObject *resultobj = 0;
37912 wxWindow *arg1 = (wxWindow *) 0 ;
37913 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37914 void *argp1 = 0 ;
37915 int res1 = 0 ;
37916 int res2 = 0 ;
37917 PyObject * obj0 = 0 ;
37918 PyObject * obj1 = 0 ;
37919 char * kwnames[] = {
37920 (char *) "self",(char *) "dropTarget", NULL
37921 };
37922
37923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",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_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37927 }
37928 arg1 = reinterpret_cast< wxWindow * >(argp1);
37929 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37930 if (!SWIG_IsOK(res2)) {
37931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37932 }
37933 {
37934 PyThreadState* __tstate = wxPyBeginAllowThreads();
37935 (arg1)->SetDropTarget(arg2);
37936 wxPyEndAllowThreads(__tstate);
37937 if (PyErr_Occurred()) SWIG_fail;
37938 }
37939 resultobj = SWIG_Py_Void();
37940 return resultobj;
37941 fail:
37942 return NULL;
37943 }
37944
37945
37946 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37947 PyObject *resultobj = 0;
37948 wxWindow *arg1 = (wxWindow *) 0 ;
37949 wxPyDropTarget *result = 0 ;
37950 void *argp1 = 0 ;
37951 int res1 = 0 ;
37952 PyObject *swig_obj[1] ;
37953
37954 if (!args) SWIG_fail;
37955 swig_obj[0] = args;
37956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37957 if (!SWIG_IsOK(res1)) {
37958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37959 }
37960 arg1 = reinterpret_cast< wxWindow * >(argp1);
37961 {
37962 PyThreadState* __tstate = wxPyBeginAllowThreads();
37963 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37964 wxPyEndAllowThreads(__tstate);
37965 if (PyErr_Occurred()) SWIG_fail;
37966 }
37967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37968 return resultobj;
37969 fail:
37970 return NULL;
37971 }
37972
37973
37974 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37975 PyObject *resultobj = 0;
37976 wxWindow *arg1 = (wxWindow *) 0 ;
37977 bool arg2 ;
37978 void *argp1 = 0 ;
37979 int res1 = 0 ;
37980 bool val2 ;
37981 int ecode2 = 0 ;
37982 PyObject * obj0 = 0 ;
37983 PyObject * obj1 = 0 ;
37984 char * kwnames[] = {
37985 (char *) "self",(char *) "accept", NULL
37986 };
37987
37988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37990 if (!SWIG_IsOK(res1)) {
37991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37992 }
37993 arg1 = reinterpret_cast< wxWindow * >(argp1);
37994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37995 if (!SWIG_IsOK(ecode2)) {
37996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37997 }
37998 arg2 = static_cast< bool >(val2);
37999 {
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 (arg1)->DragAcceptFiles(arg2);
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 resultobj = SWIG_Py_Void();
38006 return resultobj;
38007 fail:
38008 return NULL;
38009 }
38010
38011
38012 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38013 PyObject *resultobj = 0;
38014 wxWindow *arg1 = (wxWindow *) 0 ;
38015 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38016 void *argp1 = 0 ;
38017 int res1 = 0 ;
38018 int res2 = 0 ;
38019 PyObject * obj0 = 0 ;
38020 PyObject * obj1 = 0 ;
38021 char * kwnames[] = {
38022 (char *) "self",(char *) "constraints", NULL
38023 };
38024
38025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38027 if (!SWIG_IsOK(res1)) {
38028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38029 }
38030 arg1 = reinterpret_cast< wxWindow * >(argp1);
38031 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38032 if (!SWIG_IsOK(res2)) {
38033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38034 }
38035 {
38036 PyThreadState* __tstate = wxPyBeginAllowThreads();
38037 (arg1)->SetConstraints(arg2);
38038 wxPyEndAllowThreads(__tstate);
38039 if (PyErr_Occurred()) SWIG_fail;
38040 }
38041 resultobj = SWIG_Py_Void();
38042 return resultobj;
38043 fail:
38044 return NULL;
38045 }
38046
38047
38048 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38049 PyObject *resultobj = 0;
38050 wxWindow *arg1 = (wxWindow *) 0 ;
38051 wxLayoutConstraints *result = 0 ;
38052 void *argp1 = 0 ;
38053 int res1 = 0 ;
38054 PyObject *swig_obj[1] ;
38055
38056 if (!args) SWIG_fail;
38057 swig_obj[0] = args;
38058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38059 if (!SWIG_IsOK(res1)) {
38060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38061 }
38062 arg1 = reinterpret_cast< wxWindow * >(argp1);
38063 {
38064 PyThreadState* __tstate = wxPyBeginAllowThreads();
38065 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38066 wxPyEndAllowThreads(__tstate);
38067 if (PyErr_Occurred()) SWIG_fail;
38068 }
38069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38077 PyObject *resultobj = 0;
38078 wxWindow *arg1 = (wxWindow *) 0 ;
38079 bool arg2 ;
38080 void *argp1 = 0 ;
38081 int res1 = 0 ;
38082 bool val2 ;
38083 int ecode2 = 0 ;
38084 PyObject * obj0 = 0 ;
38085 PyObject * obj1 = 0 ;
38086 char * kwnames[] = {
38087 (char *) "self",(char *) "autoLayout", NULL
38088 };
38089
38090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38092 if (!SWIG_IsOK(res1)) {
38093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38094 }
38095 arg1 = reinterpret_cast< wxWindow * >(argp1);
38096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38097 if (!SWIG_IsOK(ecode2)) {
38098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38099 }
38100 arg2 = static_cast< bool >(val2);
38101 {
38102 PyThreadState* __tstate = wxPyBeginAllowThreads();
38103 (arg1)->SetAutoLayout(arg2);
38104 wxPyEndAllowThreads(__tstate);
38105 if (PyErr_Occurred()) SWIG_fail;
38106 }
38107 resultobj = SWIG_Py_Void();
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38115 PyObject *resultobj = 0;
38116 wxWindow *arg1 = (wxWindow *) 0 ;
38117 bool result;
38118 void *argp1 = 0 ;
38119 int res1 = 0 ;
38120 PyObject *swig_obj[1] ;
38121
38122 if (!args) SWIG_fail;
38123 swig_obj[0] = args;
38124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38125 if (!SWIG_IsOK(res1)) {
38126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38127 }
38128 arg1 = reinterpret_cast< wxWindow * >(argp1);
38129 {
38130 PyThreadState* __tstate = wxPyBeginAllowThreads();
38131 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 {
38136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38137 }
38138 return resultobj;
38139 fail:
38140 return NULL;
38141 }
38142
38143
38144 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38145 PyObject *resultobj = 0;
38146 wxWindow *arg1 = (wxWindow *) 0 ;
38147 bool result;
38148 void *argp1 = 0 ;
38149 int res1 = 0 ;
38150 PyObject *swig_obj[1] ;
38151
38152 if (!args) SWIG_fail;
38153 swig_obj[0] = args;
38154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38155 if (!SWIG_IsOK(res1)) {
38156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38157 }
38158 arg1 = reinterpret_cast< wxWindow * >(argp1);
38159 {
38160 PyThreadState* __tstate = wxPyBeginAllowThreads();
38161 result = (bool)(arg1)->Layout();
38162 wxPyEndAllowThreads(__tstate);
38163 if (PyErr_Occurred()) SWIG_fail;
38164 }
38165 {
38166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38167 }
38168 return resultobj;
38169 fail:
38170 return NULL;
38171 }
38172
38173
38174 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38175 PyObject *resultobj = 0;
38176 wxWindow *arg1 = (wxWindow *) 0 ;
38177 wxSizer *arg2 = (wxSizer *) 0 ;
38178 bool arg3 = (bool) true ;
38179 void *argp1 = 0 ;
38180 int res1 = 0 ;
38181 int res2 = 0 ;
38182 bool val3 ;
38183 int ecode3 = 0 ;
38184 PyObject * obj0 = 0 ;
38185 PyObject * obj1 = 0 ;
38186 PyObject * obj2 = 0 ;
38187 char * kwnames[] = {
38188 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38189 };
38190
38191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38193 if (!SWIG_IsOK(res1)) {
38194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38195 }
38196 arg1 = reinterpret_cast< wxWindow * >(argp1);
38197 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38198 if (!SWIG_IsOK(res2)) {
38199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38200 }
38201 if (obj2) {
38202 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38203 if (!SWIG_IsOK(ecode3)) {
38204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38205 }
38206 arg3 = static_cast< bool >(val3);
38207 }
38208 {
38209 PyThreadState* __tstate = wxPyBeginAllowThreads();
38210 (arg1)->SetSizer(arg2,arg3);
38211 wxPyEndAllowThreads(__tstate);
38212 if (PyErr_Occurred()) SWIG_fail;
38213 }
38214 resultobj = SWIG_Py_Void();
38215 return resultobj;
38216 fail:
38217 return NULL;
38218 }
38219
38220
38221 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38222 PyObject *resultobj = 0;
38223 wxWindow *arg1 = (wxWindow *) 0 ;
38224 wxSizer *arg2 = (wxSizer *) 0 ;
38225 bool arg3 = (bool) true ;
38226 void *argp1 = 0 ;
38227 int res1 = 0 ;
38228 int res2 = 0 ;
38229 bool val3 ;
38230 int ecode3 = 0 ;
38231 PyObject * obj0 = 0 ;
38232 PyObject * obj1 = 0 ;
38233 PyObject * obj2 = 0 ;
38234 char * kwnames[] = {
38235 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38236 };
38237
38238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38240 if (!SWIG_IsOK(res1)) {
38241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38242 }
38243 arg1 = reinterpret_cast< wxWindow * >(argp1);
38244 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38245 if (!SWIG_IsOK(res2)) {
38246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38247 }
38248 if (obj2) {
38249 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38250 if (!SWIG_IsOK(ecode3)) {
38251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38252 }
38253 arg3 = static_cast< bool >(val3);
38254 }
38255 {
38256 PyThreadState* __tstate = wxPyBeginAllowThreads();
38257 (arg1)->SetSizerAndFit(arg2,arg3);
38258 wxPyEndAllowThreads(__tstate);
38259 if (PyErr_Occurred()) SWIG_fail;
38260 }
38261 resultobj = SWIG_Py_Void();
38262 return resultobj;
38263 fail:
38264 return NULL;
38265 }
38266
38267
38268 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38269 PyObject *resultobj = 0;
38270 wxWindow *arg1 = (wxWindow *) 0 ;
38271 wxSizer *result = 0 ;
38272 void *argp1 = 0 ;
38273 int res1 = 0 ;
38274 PyObject *swig_obj[1] ;
38275
38276 if (!args) SWIG_fail;
38277 swig_obj[0] = args;
38278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38279 if (!SWIG_IsOK(res1)) {
38280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38281 }
38282 arg1 = reinterpret_cast< wxWindow * >(argp1);
38283 {
38284 PyThreadState* __tstate = wxPyBeginAllowThreads();
38285 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 {
38290 resultobj = wxPyMake_wxObject(result, (bool)0);
38291 }
38292 return resultobj;
38293 fail:
38294 return NULL;
38295 }
38296
38297
38298 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38299 PyObject *resultobj = 0;
38300 wxWindow *arg1 = (wxWindow *) 0 ;
38301 wxSizer *arg2 = (wxSizer *) 0 ;
38302 void *argp1 = 0 ;
38303 int res1 = 0 ;
38304 void *argp2 = 0 ;
38305 int res2 = 0 ;
38306 PyObject * obj0 = 0 ;
38307 PyObject * obj1 = 0 ;
38308 char * kwnames[] = {
38309 (char *) "self",(char *) "sizer", NULL
38310 };
38311
38312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38314 if (!SWIG_IsOK(res1)) {
38315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38316 }
38317 arg1 = reinterpret_cast< wxWindow * >(argp1);
38318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38319 if (!SWIG_IsOK(res2)) {
38320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38321 }
38322 arg2 = reinterpret_cast< wxSizer * >(argp2);
38323 {
38324 PyThreadState* __tstate = wxPyBeginAllowThreads();
38325 (arg1)->SetContainingSizer(arg2);
38326 wxPyEndAllowThreads(__tstate);
38327 if (PyErr_Occurred()) SWIG_fail;
38328 }
38329 resultobj = SWIG_Py_Void();
38330 return resultobj;
38331 fail:
38332 return NULL;
38333 }
38334
38335
38336 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38337 PyObject *resultobj = 0;
38338 wxWindow *arg1 = (wxWindow *) 0 ;
38339 wxSizer *result = 0 ;
38340 void *argp1 = 0 ;
38341 int res1 = 0 ;
38342 PyObject *swig_obj[1] ;
38343
38344 if (!args) SWIG_fail;
38345 swig_obj[0] = args;
38346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38347 if (!SWIG_IsOK(res1)) {
38348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38349 }
38350 arg1 = reinterpret_cast< wxWindow * >(argp1);
38351 {
38352 PyThreadState* __tstate = wxPyBeginAllowThreads();
38353 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38354 wxPyEndAllowThreads(__tstate);
38355 if (PyErr_Occurred()) SWIG_fail;
38356 }
38357 {
38358 resultobj = wxPyMake_wxObject(result, (bool)0);
38359 }
38360 return resultobj;
38361 fail:
38362 return NULL;
38363 }
38364
38365
38366 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38367 PyObject *resultobj = 0;
38368 wxWindow *arg1 = (wxWindow *) 0 ;
38369 void *argp1 = 0 ;
38370 int res1 = 0 ;
38371 PyObject *swig_obj[1] ;
38372
38373 if (!args) SWIG_fail;
38374 swig_obj[0] = args;
38375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38376 if (!SWIG_IsOK(res1)) {
38377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38378 }
38379 arg1 = reinterpret_cast< wxWindow * >(argp1);
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 (arg1)->InheritAttributes();
38383 wxPyEndAllowThreads(__tstate);
38384 if (PyErr_Occurred()) SWIG_fail;
38385 }
38386 resultobj = SWIG_Py_Void();
38387 return resultobj;
38388 fail:
38389 return NULL;
38390 }
38391
38392
38393 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38394 PyObject *resultobj = 0;
38395 wxWindow *arg1 = (wxWindow *) 0 ;
38396 bool result;
38397 void *argp1 = 0 ;
38398 int res1 = 0 ;
38399 PyObject *swig_obj[1] ;
38400
38401 if (!args) SWIG_fail;
38402 swig_obj[0] = args;
38403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38404 if (!SWIG_IsOK(res1)) {
38405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38406 }
38407 arg1 = reinterpret_cast< wxWindow * >(argp1);
38408 {
38409 PyThreadState* __tstate = wxPyBeginAllowThreads();
38410 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38411 wxPyEndAllowThreads(__tstate);
38412 if (PyErr_Occurred()) SWIG_fail;
38413 }
38414 {
38415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38416 }
38417 return resultobj;
38418 fail:
38419 return NULL;
38420 }
38421
38422
38423 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38424 PyObject *resultobj = 0;
38425 wxWindow *arg1 = (wxWindow *) 0 ;
38426 bool result;
38427 void *argp1 = 0 ;
38428 int res1 = 0 ;
38429 PyObject *swig_obj[1] ;
38430
38431 if (!args) SWIG_fail;
38432 swig_obj[0] = args;
38433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38434 if (!SWIG_IsOK(res1)) {
38435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38436 }
38437 arg1 = reinterpret_cast< wxWindow * >(argp1);
38438 {
38439 PyThreadState* __tstate = wxPyBeginAllowThreads();
38440 result = (bool)(arg1)->CanSetTransparent();
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 {
38445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38446 }
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38454 PyObject *resultobj = 0;
38455 wxWindow *arg1 = (wxWindow *) 0 ;
38456 byte arg2 ;
38457 bool result;
38458 void *argp1 = 0 ;
38459 int res1 = 0 ;
38460 unsigned char val2 ;
38461 int ecode2 = 0 ;
38462 PyObject * obj0 = 0 ;
38463 PyObject * obj1 = 0 ;
38464 char * kwnames[] = {
38465 (char *) "self",(char *) "alpha", NULL
38466 };
38467
38468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38470 if (!SWIG_IsOK(res1)) {
38471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38472 }
38473 arg1 = reinterpret_cast< wxWindow * >(argp1);
38474 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38475 if (!SWIG_IsOK(ecode2)) {
38476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38477 }
38478 arg2 = static_cast< byte >(val2);
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 result = (bool)(arg1)->SetTransparent(arg2);
38482 wxPyEndAllowThreads(__tstate);
38483 if (PyErr_Occurred()) SWIG_fail;
38484 }
38485 {
38486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38487 }
38488 return resultobj;
38489 fail:
38490 return NULL;
38491 }
38492
38493
38494 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38495 PyObject *obj;
38496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38497 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38498 return SWIG_Py_Void();
38499 }
38500
38501 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38502 return SWIG_Python_InitShadowInstance(args);
38503 }
38504
38505 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38506 PyObject *resultobj = 0;
38507 long arg1 ;
38508 wxWindow *arg2 = (wxWindow *) NULL ;
38509 wxWindow *result = 0 ;
38510 long val1 ;
38511 int ecode1 = 0 ;
38512 void *argp2 = 0 ;
38513 int res2 = 0 ;
38514 PyObject * obj0 = 0 ;
38515 PyObject * obj1 = 0 ;
38516 char * kwnames[] = {
38517 (char *) "id",(char *) "parent", NULL
38518 };
38519
38520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38521 ecode1 = SWIG_AsVal_long(obj0, &val1);
38522 if (!SWIG_IsOK(ecode1)) {
38523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38524 }
38525 arg1 = static_cast< long >(val1);
38526 if (obj1) {
38527 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38528 if (!SWIG_IsOK(res2)) {
38529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38530 }
38531 arg2 = reinterpret_cast< wxWindow * >(argp2);
38532 }
38533 {
38534 if (!wxPyCheckForApp()) SWIG_fail;
38535 PyThreadState* __tstate = wxPyBeginAllowThreads();
38536 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38537 wxPyEndAllowThreads(__tstate);
38538 if (PyErr_Occurred()) SWIG_fail;
38539 }
38540 {
38541 resultobj = wxPyMake_wxObject(result, 0);
38542 }
38543 return resultobj;
38544 fail:
38545 return NULL;
38546 }
38547
38548
38549 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38550 PyObject *resultobj = 0;
38551 wxString *arg1 = 0 ;
38552 wxWindow *arg2 = (wxWindow *) NULL ;
38553 wxWindow *result = 0 ;
38554 bool temp1 = false ;
38555 void *argp2 = 0 ;
38556 int res2 = 0 ;
38557 PyObject * obj0 = 0 ;
38558 PyObject * obj1 = 0 ;
38559 char * kwnames[] = {
38560 (char *) "name",(char *) "parent", NULL
38561 };
38562
38563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38564 {
38565 arg1 = wxString_in_helper(obj0);
38566 if (arg1 == NULL) SWIG_fail;
38567 temp1 = true;
38568 }
38569 if (obj1) {
38570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38571 if (!SWIG_IsOK(res2)) {
38572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38573 }
38574 arg2 = reinterpret_cast< wxWindow * >(argp2);
38575 }
38576 {
38577 if (!wxPyCheckForApp()) SWIG_fail;
38578 PyThreadState* __tstate = wxPyBeginAllowThreads();
38579 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38580 wxPyEndAllowThreads(__tstate);
38581 if (PyErr_Occurred()) SWIG_fail;
38582 }
38583 {
38584 resultobj = wxPyMake_wxObject(result, 0);
38585 }
38586 {
38587 if (temp1)
38588 delete arg1;
38589 }
38590 return resultobj;
38591 fail:
38592 {
38593 if (temp1)
38594 delete arg1;
38595 }
38596 return NULL;
38597 }
38598
38599
38600 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38601 PyObject *resultobj = 0;
38602 wxString *arg1 = 0 ;
38603 wxWindow *arg2 = (wxWindow *) NULL ;
38604 wxWindow *result = 0 ;
38605 bool temp1 = false ;
38606 void *argp2 = 0 ;
38607 int res2 = 0 ;
38608 PyObject * obj0 = 0 ;
38609 PyObject * obj1 = 0 ;
38610 char * kwnames[] = {
38611 (char *) "label",(char *) "parent", NULL
38612 };
38613
38614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38615 {
38616 arg1 = wxString_in_helper(obj0);
38617 if (arg1 == NULL) SWIG_fail;
38618 temp1 = true;
38619 }
38620 if (obj1) {
38621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38622 if (!SWIG_IsOK(res2)) {
38623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38624 }
38625 arg2 = reinterpret_cast< wxWindow * >(argp2);
38626 }
38627 {
38628 if (!wxPyCheckForApp()) SWIG_fail;
38629 PyThreadState* __tstate = wxPyBeginAllowThreads();
38630 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38631 wxPyEndAllowThreads(__tstate);
38632 if (PyErr_Occurred()) SWIG_fail;
38633 }
38634 {
38635 resultobj = wxPyMake_wxObject(result, 0);
38636 }
38637 {
38638 if (temp1)
38639 delete arg1;
38640 }
38641 return resultobj;
38642 fail:
38643 {
38644 if (temp1)
38645 delete arg1;
38646 }
38647 return NULL;
38648 }
38649
38650
38651 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38652 PyObject *resultobj = 0;
38653 wxWindow *arg1 = (wxWindow *) 0 ;
38654 unsigned long arg2 ;
38655 wxWindow *result = 0 ;
38656 void *argp1 = 0 ;
38657 int res1 = 0 ;
38658 unsigned long val2 ;
38659 int ecode2 = 0 ;
38660 PyObject * obj0 = 0 ;
38661 PyObject * obj1 = 0 ;
38662 char * kwnames[] = {
38663 (char *) "parent",(char *) "_hWnd", NULL
38664 };
38665
38666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38668 if (!SWIG_IsOK(res1)) {
38669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38670 }
38671 arg1 = reinterpret_cast< wxWindow * >(argp1);
38672 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38673 if (!SWIG_IsOK(ecode2)) {
38674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38675 }
38676 arg2 = static_cast< unsigned long >(val2);
38677 {
38678 PyThreadState* __tstate = wxPyBeginAllowThreads();
38679 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38680 wxPyEndAllowThreads(__tstate);
38681 if (PyErr_Occurred()) SWIG_fail;
38682 }
38683 {
38684 resultobj = wxPyMake_wxObject(result, 0);
38685 }
38686 return resultobj;
38687 fail:
38688 return NULL;
38689 }
38690
38691
38692 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38693 PyObject *resultobj = 0;
38694 PyObject *result = 0 ;
38695
38696 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (PyObject *)GetTopLevelWindows();
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 resultobj = result;
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38711 PyObject *resultobj = 0;
38712 wxValidator *result = 0 ;
38713
38714 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 result = (wxValidator *)new wxValidator();
38718 wxPyEndAllowThreads(__tstate);
38719 if (PyErr_Occurred()) SWIG_fail;
38720 }
38721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38722 return resultobj;
38723 fail:
38724 return NULL;
38725 }
38726
38727
38728 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38729 PyObject *resultobj = 0;
38730 wxValidator *arg1 = (wxValidator *) 0 ;
38731 wxValidator *result = 0 ;
38732 void *argp1 = 0 ;
38733 int res1 = 0 ;
38734 PyObject *swig_obj[1] ;
38735
38736 if (!args) SWIG_fail;
38737 swig_obj[0] = args;
38738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38739 if (!SWIG_IsOK(res1)) {
38740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38741 }
38742 arg1 = reinterpret_cast< wxValidator * >(argp1);
38743 {
38744 PyThreadState* __tstate = wxPyBeginAllowThreads();
38745 result = (wxValidator *)(arg1)->Clone();
38746 wxPyEndAllowThreads(__tstate);
38747 if (PyErr_Occurred()) SWIG_fail;
38748 }
38749 {
38750 resultobj = wxPyMake_wxObject(result, 0);
38751 }
38752 return resultobj;
38753 fail:
38754 return NULL;
38755 }
38756
38757
38758 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38759 PyObject *resultobj = 0;
38760 wxValidator *arg1 = (wxValidator *) 0 ;
38761 wxWindow *arg2 = (wxWindow *) 0 ;
38762 bool result;
38763 void *argp1 = 0 ;
38764 int res1 = 0 ;
38765 void *argp2 = 0 ;
38766 int res2 = 0 ;
38767 PyObject * obj0 = 0 ;
38768 PyObject * obj1 = 0 ;
38769 char * kwnames[] = {
38770 (char *) "self",(char *) "parent", NULL
38771 };
38772
38773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38775 if (!SWIG_IsOK(res1)) {
38776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38777 }
38778 arg1 = reinterpret_cast< wxValidator * >(argp1);
38779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38780 if (!SWIG_IsOK(res2)) {
38781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38782 }
38783 arg2 = reinterpret_cast< wxWindow * >(argp2);
38784 {
38785 PyThreadState* __tstate = wxPyBeginAllowThreads();
38786 result = (bool)(arg1)->Validate(arg2);
38787 wxPyEndAllowThreads(__tstate);
38788 if (PyErr_Occurred()) SWIG_fail;
38789 }
38790 {
38791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38792 }
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38800 PyObject *resultobj = 0;
38801 wxValidator *arg1 = (wxValidator *) 0 ;
38802 bool result;
38803 void *argp1 = 0 ;
38804 int res1 = 0 ;
38805 PyObject *swig_obj[1] ;
38806
38807 if (!args) SWIG_fail;
38808 swig_obj[0] = args;
38809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38810 if (!SWIG_IsOK(res1)) {
38811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38812 }
38813 arg1 = reinterpret_cast< wxValidator * >(argp1);
38814 {
38815 PyThreadState* __tstate = wxPyBeginAllowThreads();
38816 result = (bool)(arg1)->TransferToWindow();
38817 wxPyEndAllowThreads(__tstate);
38818 if (PyErr_Occurred()) SWIG_fail;
38819 }
38820 {
38821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38822 }
38823 return resultobj;
38824 fail:
38825 return NULL;
38826 }
38827
38828
38829 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38830 PyObject *resultobj = 0;
38831 wxValidator *arg1 = (wxValidator *) 0 ;
38832 bool result;
38833 void *argp1 = 0 ;
38834 int res1 = 0 ;
38835 PyObject *swig_obj[1] ;
38836
38837 if (!args) SWIG_fail;
38838 swig_obj[0] = args;
38839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38840 if (!SWIG_IsOK(res1)) {
38841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38842 }
38843 arg1 = reinterpret_cast< wxValidator * >(argp1);
38844 {
38845 PyThreadState* __tstate = wxPyBeginAllowThreads();
38846 result = (bool)(arg1)->TransferFromWindow();
38847 wxPyEndAllowThreads(__tstate);
38848 if (PyErr_Occurred()) SWIG_fail;
38849 }
38850 {
38851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38852 }
38853 return resultobj;
38854 fail:
38855 return NULL;
38856 }
38857
38858
38859 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38860 PyObject *resultobj = 0;
38861 wxValidator *arg1 = (wxValidator *) 0 ;
38862 wxWindow *result = 0 ;
38863 void *argp1 = 0 ;
38864 int res1 = 0 ;
38865 PyObject *swig_obj[1] ;
38866
38867 if (!args) SWIG_fail;
38868 swig_obj[0] = args;
38869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38870 if (!SWIG_IsOK(res1)) {
38871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38872 }
38873 arg1 = reinterpret_cast< wxValidator * >(argp1);
38874 {
38875 PyThreadState* __tstate = wxPyBeginAllowThreads();
38876 result = (wxWindow *)(arg1)->GetWindow();
38877 wxPyEndAllowThreads(__tstate);
38878 if (PyErr_Occurred()) SWIG_fail;
38879 }
38880 {
38881 resultobj = wxPyMake_wxObject(result, 0);
38882 }
38883 return resultobj;
38884 fail:
38885 return NULL;
38886 }
38887
38888
38889 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38890 PyObject *resultobj = 0;
38891 wxValidator *arg1 = (wxValidator *) 0 ;
38892 wxWindow *arg2 = (wxWindow *) 0 ;
38893 void *argp1 = 0 ;
38894 int res1 = 0 ;
38895 void *argp2 = 0 ;
38896 int res2 = 0 ;
38897 PyObject * obj0 = 0 ;
38898 PyObject * obj1 = 0 ;
38899 char * kwnames[] = {
38900 (char *) "self",(char *) "window", NULL
38901 };
38902
38903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38905 if (!SWIG_IsOK(res1)) {
38906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38907 }
38908 arg1 = reinterpret_cast< wxValidator * >(argp1);
38909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38910 if (!SWIG_IsOK(res2)) {
38911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38912 }
38913 arg2 = reinterpret_cast< wxWindow * >(argp2);
38914 {
38915 PyThreadState* __tstate = wxPyBeginAllowThreads();
38916 (arg1)->SetWindow(arg2);
38917 wxPyEndAllowThreads(__tstate);
38918 if (PyErr_Occurred()) SWIG_fail;
38919 }
38920 resultobj = SWIG_Py_Void();
38921 return resultobj;
38922 fail:
38923 return NULL;
38924 }
38925
38926
38927 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38928 PyObject *resultobj = 0;
38929 bool result;
38930
38931 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38932 {
38933 PyThreadState* __tstate = wxPyBeginAllowThreads();
38934 result = (bool)wxValidator::IsSilent();
38935 wxPyEndAllowThreads(__tstate);
38936 if (PyErr_Occurred()) SWIG_fail;
38937 }
38938 {
38939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38940 }
38941 return resultobj;
38942 fail:
38943 return NULL;
38944 }
38945
38946
38947 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38948 PyObject *resultobj = 0;
38949 int arg1 = (int) true ;
38950 int val1 ;
38951 int ecode1 = 0 ;
38952 PyObject * obj0 = 0 ;
38953 char * kwnames[] = {
38954 (char *) "doIt", NULL
38955 };
38956
38957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38958 if (obj0) {
38959 ecode1 = SWIG_AsVal_int(obj0, &val1);
38960 if (!SWIG_IsOK(ecode1)) {
38961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38962 }
38963 arg1 = static_cast< int >(val1);
38964 }
38965 {
38966 PyThreadState* __tstate = wxPyBeginAllowThreads();
38967 wxValidator::SetBellOnError(arg1);
38968 wxPyEndAllowThreads(__tstate);
38969 if (PyErr_Occurred()) SWIG_fail;
38970 }
38971 resultobj = SWIG_Py_Void();
38972 return resultobj;
38973 fail:
38974 return NULL;
38975 }
38976
38977
38978 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38979 PyObject *obj;
38980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38981 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38982 return SWIG_Py_Void();
38983 }
38984
38985 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38986 return SWIG_Python_InitShadowInstance(args);
38987 }
38988
38989 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38990 PyObject *resultobj = 0;
38991 wxPyValidator *result = 0 ;
38992
38993 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38994 {
38995 PyThreadState* __tstate = wxPyBeginAllowThreads();
38996 result = (wxPyValidator *)new wxPyValidator();
38997 wxPyEndAllowThreads(__tstate);
38998 if (PyErr_Occurred()) SWIG_fail;
38999 }
39000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39001 return resultobj;
39002 fail:
39003 return NULL;
39004 }
39005
39006
39007 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39008 PyObject *resultobj = 0;
39009 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39010 PyObject *arg2 = (PyObject *) 0 ;
39011 PyObject *arg3 = (PyObject *) 0 ;
39012 int arg4 = (int) true ;
39013 void *argp1 = 0 ;
39014 int res1 = 0 ;
39015 int val4 ;
39016 int ecode4 = 0 ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 PyObject * obj2 = 0 ;
39020 PyObject * obj3 = 0 ;
39021 char * kwnames[] = {
39022 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39023 };
39024
39025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39027 if (!SWIG_IsOK(res1)) {
39028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39029 }
39030 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39031 arg2 = obj1;
39032 arg3 = obj2;
39033 if (obj3) {
39034 ecode4 = SWIG_AsVal_int(obj3, &val4);
39035 if (!SWIG_IsOK(ecode4)) {
39036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39037 }
39038 arg4 = static_cast< int >(val4);
39039 }
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 resultobj = SWIG_Py_Void();
39047 return resultobj;
39048 fail:
39049 return NULL;
39050 }
39051
39052
39053 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39054 PyObject *obj;
39055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39056 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39057 return SWIG_Py_Void();
39058 }
39059
39060 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39061 return SWIG_Python_InitShadowInstance(args);
39062 }
39063
39064 SWIGINTERN int DefaultValidator_set(PyObject *) {
39065 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39066 return 1;
39067 }
39068
39069
39070 SWIGINTERN PyObject *DefaultValidator_get(void) {
39071 PyObject *pyobj = 0;
39072
39073 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39074 return pyobj;
39075 }
39076
39077
39078 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39079 PyObject *resultobj = 0;
39080 wxString const &arg1_defvalue = wxPyEmptyString ;
39081 wxString *arg1 = (wxString *) &arg1_defvalue ;
39082 long arg2 = (long) 0 ;
39083 wxMenu *result = 0 ;
39084 bool temp1 = false ;
39085 long val2 ;
39086 int ecode2 = 0 ;
39087 PyObject * obj0 = 0 ;
39088 PyObject * obj1 = 0 ;
39089 char * kwnames[] = {
39090 (char *) "title",(char *) "style", NULL
39091 };
39092
39093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39094 if (obj0) {
39095 {
39096 arg1 = wxString_in_helper(obj0);
39097 if (arg1 == NULL) SWIG_fail;
39098 temp1 = true;
39099 }
39100 }
39101 if (obj1) {
39102 ecode2 = SWIG_AsVal_long(obj1, &val2);
39103 if (!SWIG_IsOK(ecode2)) {
39104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39105 }
39106 arg2 = static_cast< long >(val2);
39107 }
39108 {
39109 if (!wxPyCheckForApp()) SWIG_fail;
39110 PyThreadState* __tstate = wxPyBeginAllowThreads();
39111 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39112 wxPyEndAllowThreads(__tstate);
39113 if (PyErr_Occurred()) SWIG_fail;
39114 }
39115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39116 {
39117 if (temp1)
39118 delete arg1;
39119 }
39120 return resultobj;
39121 fail:
39122 {
39123 if (temp1)
39124 delete arg1;
39125 }
39126 return NULL;
39127 }
39128
39129
39130 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39131 PyObject *resultobj = 0;
39132 wxMenu *arg1 = (wxMenu *) 0 ;
39133 int arg2 ;
39134 wxString const &arg3_defvalue = wxPyEmptyString ;
39135 wxString *arg3 = (wxString *) &arg3_defvalue ;
39136 wxString const &arg4_defvalue = wxPyEmptyString ;
39137 wxString *arg4 = (wxString *) &arg4_defvalue ;
39138 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39139 wxMenuItem *result = 0 ;
39140 void *argp1 = 0 ;
39141 int res1 = 0 ;
39142 int val2 ;
39143 int ecode2 = 0 ;
39144 bool temp3 = false ;
39145 bool temp4 = false ;
39146 int val5 ;
39147 int ecode5 = 0 ;
39148 PyObject * obj0 = 0 ;
39149 PyObject * obj1 = 0 ;
39150 PyObject * obj2 = 0 ;
39151 PyObject * obj3 = 0 ;
39152 PyObject * obj4 = 0 ;
39153 char * kwnames[] = {
39154 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39155 };
39156
39157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39159 if (!SWIG_IsOK(res1)) {
39160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39161 }
39162 arg1 = reinterpret_cast< wxMenu * >(argp1);
39163 ecode2 = SWIG_AsVal_int(obj1, &val2);
39164 if (!SWIG_IsOK(ecode2)) {
39165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39166 }
39167 arg2 = static_cast< int >(val2);
39168 if (obj2) {
39169 {
39170 arg3 = wxString_in_helper(obj2);
39171 if (arg3 == NULL) SWIG_fail;
39172 temp3 = true;
39173 }
39174 }
39175 if (obj3) {
39176 {
39177 arg4 = wxString_in_helper(obj3);
39178 if (arg4 == NULL) SWIG_fail;
39179 temp4 = true;
39180 }
39181 }
39182 if (obj4) {
39183 ecode5 = SWIG_AsVal_int(obj4, &val5);
39184 if (!SWIG_IsOK(ecode5)) {
39185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39186 }
39187 arg5 = static_cast< wxItemKind >(val5);
39188 }
39189 {
39190 PyThreadState* __tstate = wxPyBeginAllowThreads();
39191 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39192 wxPyEndAllowThreads(__tstate);
39193 if (PyErr_Occurred()) SWIG_fail;
39194 }
39195 {
39196 resultobj = wxPyMake_wxObject(result, (bool)0);
39197 }
39198 {
39199 if (temp3)
39200 delete arg3;
39201 }
39202 {
39203 if (temp4)
39204 delete arg4;
39205 }
39206 return resultobj;
39207 fail:
39208 {
39209 if (temp3)
39210 delete arg3;
39211 }
39212 {
39213 if (temp4)
39214 delete arg4;
39215 }
39216 return NULL;
39217 }
39218
39219
39220 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39221 PyObject *resultobj = 0;
39222 wxMenu *arg1 = (wxMenu *) 0 ;
39223 wxMenuItem *result = 0 ;
39224 void *argp1 = 0 ;
39225 int res1 = 0 ;
39226 PyObject *swig_obj[1] ;
39227
39228 if (!args) SWIG_fail;
39229 swig_obj[0] = args;
39230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39231 if (!SWIG_IsOK(res1)) {
39232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39233 }
39234 arg1 = reinterpret_cast< wxMenu * >(argp1);
39235 {
39236 PyThreadState* __tstate = wxPyBeginAllowThreads();
39237 result = (wxMenuItem *)(arg1)->AppendSeparator();
39238 wxPyEndAllowThreads(__tstate);
39239 if (PyErr_Occurred()) SWIG_fail;
39240 }
39241 {
39242 resultobj = wxPyMake_wxObject(result, (bool)0);
39243 }
39244 return resultobj;
39245 fail:
39246 return NULL;
39247 }
39248
39249
39250 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39251 PyObject *resultobj = 0;
39252 wxMenu *arg1 = (wxMenu *) 0 ;
39253 int arg2 ;
39254 wxString *arg3 = 0 ;
39255 wxString const &arg4_defvalue = wxPyEmptyString ;
39256 wxString *arg4 = (wxString *) &arg4_defvalue ;
39257 wxMenuItem *result = 0 ;
39258 void *argp1 = 0 ;
39259 int res1 = 0 ;
39260 int val2 ;
39261 int ecode2 = 0 ;
39262 bool temp3 = false ;
39263 bool temp4 = false ;
39264 PyObject * obj0 = 0 ;
39265 PyObject * obj1 = 0 ;
39266 PyObject * obj2 = 0 ;
39267 PyObject * obj3 = 0 ;
39268 char * kwnames[] = {
39269 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39270 };
39271
39272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39274 if (!SWIG_IsOK(res1)) {
39275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39276 }
39277 arg1 = reinterpret_cast< wxMenu * >(argp1);
39278 ecode2 = SWIG_AsVal_int(obj1, &val2);
39279 if (!SWIG_IsOK(ecode2)) {
39280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39281 }
39282 arg2 = static_cast< int >(val2);
39283 {
39284 arg3 = wxString_in_helper(obj2);
39285 if (arg3 == NULL) SWIG_fail;
39286 temp3 = true;
39287 }
39288 if (obj3) {
39289 {
39290 arg4 = wxString_in_helper(obj3);
39291 if (arg4 == NULL) SWIG_fail;
39292 temp4 = true;
39293 }
39294 }
39295 {
39296 PyThreadState* __tstate = wxPyBeginAllowThreads();
39297 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39298 wxPyEndAllowThreads(__tstate);
39299 if (PyErr_Occurred()) SWIG_fail;
39300 }
39301 {
39302 resultobj = wxPyMake_wxObject(result, (bool)0);
39303 }
39304 {
39305 if (temp3)
39306 delete arg3;
39307 }
39308 {
39309 if (temp4)
39310 delete arg4;
39311 }
39312 return resultobj;
39313 fail:
39314 {
39315 if (temp3)
39316 delete arg3;
39317 }
39318 {
39319 if (temp4)
39320 delete arg4;
39321 }
39322 return NULL;
39323 }
39324
39325
39326 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39327 PyObject *resultobj = 0;
39328 wxMenu *arg1 = (wxMenu *) 0 ;
39329 int arg2 ;
39330 wxString *arg3 = 0 ;
39331 wxString const &arg4_defvalue = wxPyEmptyString ;
39332 wxString *arg4 = (wxString *) &arg4_defvalue ;
39333 wxMenuItem *result = 0 ;
39334 void *argp1 = 0 ;
39335 int res1 = 0 ;
39336 int val2 ;
39337 int ecode2 = 0 ;
39338 bool temp3 = false ;
39339 bool temp4 = false ;
39340 PyObject * obj0 = 0 ;
39341 PyObject * obj1 = 0 ;
39342 PyObject * obj2 = 0 ;
39343 PyObject * obj3 = 0 ;
39344 char * kwnames[] = {
39345 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39346 };
39347
39348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39350 if (!SWIG_IsOK(res1)) {
39351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39352 }
39353 arg1 = reinterpret_cast< wxMenu * >(argp1);
39354 ecode2 = SWIG_AsVal_int(obj1, &val2);
39355 if (!SWIG_IsOK(ecode2)) {
39356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39357 }
39358 arg2 = static_cast< int >(val2);
39359 {
39360 arg3 = wxString_in_helper(obj2);
39361 if (arg3 == NULL) SWIG_fail;
39362 temp3 = true;
39363 }
39364 if (obj3) {
39365 {
39366 arg4 = wxString_in_helper(obj3);
39367 if (arg4 == NULL) SWIG_fail;
39368 temp4 = true;
39369 }
39370 }
39371 {
39372 PyThreadState* __tstate = wxPyBeginAllowThreads();
39373 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39374 wxPyEndAllowThreads(__tstate);
39375 if (PyErr_Occurred()) SWIG_fail;
39376 }
39377 {
39378 resultobj = wxPyMake_wxObject(result, (bool)0);
39379 }
39380 {
39381 if (temp3)
39382 delete arg3;
39383 }
39384 {
39385 if (temp4)
39386 delete arg4;
39387 }
39388 return resultobj;
39389 fail:
39390 {
39391 if (temp3)
39392 delete arg3;
39393 }
39394 {
39395 if (temp4)
39396 delete arg4;
39397 }
39398 return NULL;
39399 }
39400
39401
39402 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39403 PyObject *resultobj = 0;
39404 wxMenu *arg1 = (wxMenu *) 0 ;
39405 int arg2 ;
39406 wxString *arg3 = 0 ;
39407 wxMenu *arg4 = (wxMenu *) 0 ;
39408 wxString const &arg5_defvalue = wxPyEmptyString ;
39409 wxString *arg5 = (wxString *) &arg5_defvalue ;
39410 wxMenuItem *result = 0 ;
39411 void *argp1 = 0 ;
39412 int res1 = 0 ;
39413 int val2 ;
39414 int ecode2 = 0 ;
39415 bool temp3 = false ;
39416 void *argp4 = 0 ;
39417 int res4 = 0 ;
39418 bool temp5 = false ;
39419 PyObject * obj0 = 0 ;
39420 PyObject * obj1 = 0 ;
39421 PyObject * obj2 = 0 ;
39422 PyObject * obj3 = 0 ;
39423 PyObject * obj4 = 0 ;
39424 char * kwnames[] = {
39425 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39426 };
39427
39428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39430 if (!SWIG_IsOK(res1)) {
39431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39432 }
39433 arg1 = reinterpret_cast< wxMenu * >(argp1);
39434 ecode2 = SWIG_AsVal_int(obj1, &val2);
39435 if (!SWIG_IsOK(ecode2)) {
39436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39437 }
39438 arg2 = static_cast< int >(val2);
39439 {
39440 arg3 = wxString_in_helper(obj2);
39441 if (arg3 == NULL) SWIG_fail;
39442 temp3 = true;
39443 }
39444 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39445 if (!SWIG_IsOK(res4)) {
39446 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39447 }
39448 arg4 = reinterpret_cast< wxMenu * >(argp4);
39449 if (obj4) {
39450 {
39451 arg5 = wxString_in_helper(obj4);
39452 if (arg5 == NULL) SWIG_fail;
39453 temp5 = true;
39454 }
39455 }
39456 {
39457 PyThreadState* __tstate = wxPyBeginAllowThreads();
39458 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39459 wxPyEndAllowThreads(__tstate);
39460 if (PyErr_Occurred()) SWIG_fail;
39461 }
39462 {
39463 resultobj = wxPyMake_wxObject(result, (bool)0);
39464 }
39465 {
39466 if (temp3)
39467 delete arg3;
39468 }
39469 {
39470 if (temp5)
39471 delete arg5;
39472 }
39473 return resultobj;
39474 fail:
39475 {
39476 if (temp3)
39477 delete arg3;
39478 }
39479 {
39480 if (temp5)
39481 delete arg5;
39482 }
39483 return NULL;
39484 }
39485
39486
39487 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39488 PyObject *resultobj = 0;
39489 wxMenu *arg1 = (wxMenu *) 0 ;
39490 wxMenu *arg2 = (wxMenu *) 0 ;
39491 wxString *arg3 = 0 ;
39492 wxString const &arg4_defvalue = wxPyEmptyString ;
39493 wxString *arg4 = (wxString *) &arg4_defvalue ;
39494 wxMenuItem *result = 0 ;
39495 void *argp1 = 0 ;
39496 int res1 = 0 ;
39497 void *argp2 = 0 ;
39498 int res2 = 0 ;
39499 bool temp3 = false ;
39500 bool temp4 = false ;
39501 PyObject * obj0 = 0 ;
39502 PyObject * obj1 = 0 ;
39503 PyObject * obj2 = 0 ;
39504 PyObject * obj3 = 0 ;
39505 char * kwnames[] = {
39506 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39507 };
39508
39509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39511 if (!SWIG_IsOK(res1)) {
39512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39513 }
39514 arg1 = reinterpret_cast< wxMenu * >(argp1);
39515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39516 if (!SWIG_IsOK(res2)) {
39517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39518 }
39519 arg2 = reinterpret_cast< wxMenu * >(argp2);
39520 {
39521 arg3 = wxString_in_helper(obj2);
39522 if (arg3 == NULL) SWIG_fail;
39523 temp3 = true;
39524 }
39525 if (obj3) {
39526 {
39527 arg4 = wxString_in_helper(obj3);
39528 if (arg4 == NULL) SWIG_fail;
39529 temp4 = true;
39530 }
39531 }
39532 {
39533 PyThreadState* __tstate = wxPyBeginAllowThreads();
39534 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39535 wxPyEndAllowThreads(__tstate);
39536 if (PyErr_Occurred()) SWIG_fail;
39537 }
39538 {
39539 resultobj = wxPyMake_wxObject(result, (bool)0);
39540 }
39541 {
39542 if (temp3)
39543 delete arg3;
39544 }
39545 {
39546 if (temp4)
39547 delete arg4;
39548 }
39549 return resultobj;
39550 fail:
39551 {
39552 if (temp3)
39553 delete arg3;
39554 }
39555 {
39556 if (temp4)
39557 delete arg4;
39558 }
39559 return NULL;
39560 }
39561
39562
39563 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39564 PyObject *resultobj = 0;
39565 wxMenu *arg1 = (wxMenu *) 0 ;
39566 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39567 wxMenuItem *result = 0 ;
39568 void *argp1 = 0 ;
39569 int res1 = 0 ;
39570 int res2 = 0 ;
39571 PyObject * obj0 = 0 ;
39572 PyObject * obj1 = 0 ;
39573 char * kwnames[] = {
39574 (char *) "self",(char *) "item", NULL
39575 };
39576
39577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39579 if (!SWIG_IsOK(res1)) {
39580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39581 }
39582 arg1 = reinterpret_cast< wxMenu * >(argp1);
39583 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39584 if (!SWIG_IsOK(res2)) {
39585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39586 }
39587 {
39588 PyThreadState* __tstate = wxPyBeginAllowThreads();
39589 result = (wxMenuItem *)(arg1)->Append(arg2);
39590 wxPyEndAllowThreads(__tstate);
39591 if (PyErr_Occurred()) SWIG_fail;
39592 }
39593 {
39594 resultobj = wxPyMake_wxObject(result, (bool)0);
39595 }
39596 return resultobj;
39597 fail:
39598 return NULL;
39599 }
39600
39601
39602 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39603 PyObject *resultobj = 0;
39604 wxMenu *arg1 = (wxMenu *) 0 ;
39605 size_t arg2 ;
39606 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39607 wxMenuItem *result = 0 ;
39608 void *argp1 = 0 ;
39609 int res1 = 0 ;
39610 size_t val2 ;
39611 int ecode2 = 0 ;
39612 int res3 = 0 ;
39613 PyObject * obj0 = 0 ;
39614 PyObject * obj1 = 0 ;
39615 PyObject * obj2 = 0 ;
39616 char * kwnames[] = {
39617 (char *) "self",(char *) "pos",(char *) "item", NULL
39618 };
39619
39620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39622 if (!SWIG_IsOK(res1)) {
39623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39624 }
39625 arg1 = reinterpret_cast< wxMenu * >(argp1);
39626 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39627 if (!SWIG_IsOK(ecode2)) {
39628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39629 }
39630 arg2 = static_cast< size_t >(val2);
39631 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39632 if (!SWIG_IsOK(res3)) {
39633 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39634 }
39635 {
39636 PyThreadState* __tstate = wxPyBeginAllowThreads();
39637 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39638 wxPyEndAllowThreads(__tstate);
39639 if (PyErr_Occurred()) SWIG_fail;
39640 }
39641 {
39642 resultobj = wxPyMake_wxObject(result, (bool)0);
39643 }
39644 return resultobj;
39645 fail:
39646 return NULL;
39647 }
39648
39649
39650 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39651 PyObject *resultobj = 0;
39652 wxMenu *arg1 = (wxMenu *) 0 ;
39653 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39654 wxMenuItem *result = 0 ;
39655 void *argp1 = 0 ;
39656 int res1 = 0 ;
39657 int res2 = 0 ;
39658 PyObject * obj0 = 0 ;
39659 PyObject * obj1 = 0 ;
39660 char * kwnames[] = {
39661 (char *) "self",(char *) "item", NULL
39662 };
39663
39664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39666 if (!SWIG_IsOK(res1)) {
39667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39668 }
39669 arg1 = reinterpret_cast< wxMenu * >(argp1);
39670 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39671 if (!SWIG_IsOK(res2)) {
39672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39673 }
39674 {
39675 PyThreadState* __tstate = wxPyBeginAllowThreads();
39676 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39677 wxPyEndAllowThreads(__tstate);
39678 if (PyErr_Occurred()) SWIG_fail;
39679 }
39680 {
39681 resultobj = wxPyMake_wxObject(result, (bool)0);
39682 }
39683 return resultobj;
39684 fail:
39685 return NULL;
39686 }
39687
39688
39689 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39690 PyObject *resultobj = 0;
39691 wxMenu *arg1 = (wxMenu *) 0 ;
39692 void *argp1 = 0 ;
39693 int res1 = 0 ;
39694 PyObject *swig_obj[1] ;
39695
39696 if (!args) SWIG_fail;
39697 swig_obj[0] = args;
39698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39699 if (!SWIG_IsOK(res1)) {
39700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39701 }
39702 arg1 = reinterpret_cast< wxMenu * >(argp1);
39703 {
39704 PyThreadState* __tstate = wxPyBeginAllowThreads();
39705 (arg1)->Break();
39706 wxPyEndAllowThreads(__tstate);
39707 if (PyErr_Occurred()) SWIG_fail;
39708 }
39709 resultobj = SWIG_Py_Void();
39710 return resultobj;
39711 fail:
39712 return NULL;
39713 }
39714
39715
39716 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39717 PyObject *resultobj = 0;
39718 wxMenu *arg1 = (wxMenu *) 0 ;
39719 size_t arg2 ;
39720 int arg3 ;
39721 wxString const &arg4_defvalue = wxPyEmptyString ;
39722 wxString *arg4 = (wxString *) &arg4_defvalue ;
39723 wxString const &arg5_defvalue = wxPyEmptyString ;
39724 wxString *arg5 = (wxString *) &arg5_defvalue ;
39725 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39726 wxMenuItem *result = 0 ;
39727 void *argp1 = 0 ;
39728 int res1 = 0 ;
39729 size_t val2 ;
39730 int ecode2 = 0 ;
39731 int val3 ;
39732 int ecode3 = 0 ;
39733 bool temp4 = false ;
39734 bool temp5 = false ;
39735 int val6 ;
39736 int ecode6 = 0 ;
39737 PyObject * obj0 = 0 ;
39738 PyObject * obj1 = 0 ;
39739 PyObject * obj2 = 0 ;
39740 PyObject * obj3 = 0 ;
39741 PyObject * obj4 = 0 ;
39742 PyObject * obj5 = 0 ;
39743 char * kwnames[] = {
39744 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39745 };
39746
39747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39749 if (!SWIG_IsOK(res1)) {
39750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39751 }
39752 arg1 = reinterpret_cast< wxMenu * >(argp1);
39753 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39754 if (!SWIG_IsOK(ecode2)) {
39755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39756 }
39757 arg2 = static_cast< size_t >(val2);
39758 ecode3 = SWIG_AsVal_int(obj2, &val3);
39759 if (!SWIG_IsOK(ecode3)) {
39760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39761 }
39762 arg3 = static_cast< int >(val3);
39763 if (obj3) {
39764 {
39765 arg4 = wxString_in_helper(obj3);
39766 if (arg4 == NULL) SWIG_fail;
39767 temp4 = true;
39768 }
39769 }
39770 if (obj4) {
39771 {
39772 arg5 = wxString_in_helper(obj4);
39773 if (arg5 == NULL) SWIG_fail;
39774 temp5 = true;
39775 }
39776 }
39777 if (obj5) {
39778 ecode6 = SWIG_AsVal_int(obj5, &val6);
39779 if (!SWIG_IsOK(ecode6)) {
39780 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39781 }
39782 arg6 = static_cast< wxItemKind >(val6);
39783 }
39784 {
39785 PyThreadState* __tstate = wxPyBeginAllowThreads();
39786 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39787 wxPyEndAllowThreads(__tstate);
39788 if (PyErr_Occurred()) SWIG_fail;
39789 }
39790 {
39791 resultobj = wxPyMake_wxObject(result, (bool)0);
39792 }
39793 {
39794 if (temp4)
39795 delete arg4;
39796 }
39797 {
39798 if (temp5)
39799 delete arg5;
39800 }
39801 return resultobj;
39802 fail:
39803 {
39804 if (temp4)
39805 delete arg4;
39806 }
39807 {
39808 if (temp5)
39809 delete arg5;
39810 }
39811 return NULL;
39812 }
39813
39814
39815 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39816 PyObject *resultobj = 0;
39817 wxMenu *arg1 = (wxMenu *) 0 ;
39818 size_t arg2 ;
39819 wxMenuItem *result = 0 ;
39820 void *argp1 = 0 ;
39821 int res1 = 0 ;
39822 size_t val2 ;
39823 int ecode2 = 0 ;
39824 PyObject * obj0 = 0 ;
39825 PyObject * obj1 = 0 ;
39826 char * kwnames[] = {
39827 (char *) "self",(char *) "pos", NULL
39828 };
39829
39830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39832 if (!SWIG_IsOK(res1)) {
39833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39834 }
39835 arg1 = reinterpret_cast< wxMenu * >(argp1);
39836 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39837 if (!SWIG_IsOK(ecode2)) {
39838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39839 }
39840 arg2 = static_cast< size_t >(val2);
39841 {
39842 PyThreadState* __tstate = wxPyBeginAllowThreads();
39843 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39844 wxPyEndAllowThreads(__tstate);
39845 if (PyErr_Occurred()) SWIG_fail;
39846 }
39847 {
39848 resultobj = wxPyMake_wxObject(result, (bool)0);
39849 }
39850 return resultobj;
39851 fail:
39852 return NULL;
39853 }
39854
39855
39856 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39857 PyObject *resultobj = 0;
39858 wxMenu *arg1 = (wxMenu *) 0 ;
39859 size_t arg2 ;
39860 int arg3 ;
39861 wxString *arg4 = 0 ;
39862 wxString const &arg5_defvalue = wxPyEmptyString ;
39863 wxString *arg5 = (wxString *) &arg5_defvalue ;
39864 wxMenuItem *result = 0 ;
39865 void *argp1 = 0 ;
39866 int res1 = 0 ;
39867 size_t val2 ;
39868 int ecode2 = 0 ;
39869 int val3 ;
39870 int ecode3 = 0 ;
39871 bool temp4 = false ;
39872 bool temp5 = false ;
39873 PyObject * obj0 = 0 ;
39874 PyObject * obj1 = 0 ;
39875 PyObject * obj2 = 0 ;
39876 PyObject * obj3 = 0 ;
39877 PyObject * obj4 = 0 ;
39878 char * kwnames[] = {
39879 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39880 };
39881
39882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39884 if (!SWIG_IsOK(res1)) {
39885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39886 }
39887 arg1 = reinterpret_cast< wxMenu * >(argp1);
39888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39889 if (!SWIG_IsOK(ecode2)) {
39890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39891 }
39892 arg2 = static_cast< size_t >(val2);
39893 ecode3 = SWIG_AsVal_int(obj2, &val3);
39894 if (!SWIG_IsOK(ecode3)) {
39895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39896 }
39897 arg3 = static_cast< int >(val3);
39898 {
39899 arg4 = wxString_in_helper(obj3);
39900 if (arg4 == NULL) SWIG_fail;
39901 temp4 = true;
39902 }
39903 if (obj4) {
39904 {
39905 arg5 = wxString_in_helper(obj4);
39906 if (arg5 == NULL) SWIG_fail;
39907 temp5 = true;
39908 }
39909 }
39910 {
39911 PyThreadState* __tstate = wxPyBeginAllowThreads();
39912 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 {
39917 resultobj = wxPyMake_wxObject(result, (bool)0);
39918 }
39919 {
39920 if (temp4)
39921 delete arg4;
39922 }
39923 {
39924 if (temp5)
39925 delete arg5;
39926 }
39927 return resultobj;
39928 fail:
39929 {
39930 if (temp4)
39931 delete arg4;
39932 }
39933 {
39934 if (temp5)
39935 delete arg5;
39936 }
39937 return NULL;
39938 }
39939
39940
39941 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39942 PyObject *resultobj = 0;
39943 wxMenu *arg1 = (wxMenu *) 0 ;
39944 size_t arg2 ;
39945 int arg3 ;
39946 wxString *arg4 = 0 ;
39947 wxString const &arg5_defvalue = wxPyEmptyString ;
39948 wxString *arg5 = (wxString *) &arg5_defvalue ;
39949 wxMenuItem *result = 0 ;
39950 void *argp1 = 0 ;
39951 int res1 = 0 ;
39952 size_t val2 ;
39953 int ecode2 = 0 ;
39954 int val3 ;
39955 int ecode3 = 0 ;
39956 bool temp4 = false ;
39957 bool temp5 = false ;
39958 PyObject * obj0 = 0 ;
39959 PyObject * obj1 = 0 ;
39960 PyObject * obj2 = 0 ;
39961 PyObject * obj3 = 0 ;
39962 PyObject * obj4 = 0 ;
39963 char * kwnames[] = {
39964 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39965 };
39966
39967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39969 if (!SWIG_IsOK(res1)) {
39970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39971 }
39972 arg1 = reinterpret_cast< wxMenu * >(argp1);
39973 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39974 if (!SWIG_IsOK(ecode2)) {
39975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39976 }
39977 arg2 = static_cast< size_t >(val2);
39978 ecode3 = SWIG_AsVal_int(obj2, &val3);
39979 if (!SWIG_IsOK(ecode3)) {
39980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39981 }
39982 arg3 = static_cast< int >(val3);
39983 {
39984 arg4 = wxString_in_helper(obj3);
39985 if (arg4 == NULL) SWIG_fail;
39986 temp4 = true;
39987 }
39988 if (obj4) {
39989 {
39990 arg5 = wxString_in_helper(obj4);
39991 if (arg5 == NULL) SWIG_fail;
39992 temp5 = true;
39993 }
39994 }
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 {
40002 resultobj = wxPyMake_wxObject(result, (bool)0);
40003 }
40004 {
40005 if (temp4)
40006 delete arg4;
40007 }
40008 {
40009 if (temp5)
40010 delete arg5;
40011 }
40012 return resultobj;
40013 fail:
40014 {
40015 if (temp4)
40016 delete arg4;
40017 }
40018 {
40019 if (temp5)
40020 delete arg5;
40021 }
40022 return NULL;
40023 }
40024
40025
40026 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40027 PyObject *resultobj = 0;
40028 wxMenu *arg1 = (wxMenu *) 0 ;
40029 size_t arg2 ;
40030 int arg3 ;
40031 wxString *arg4 = 0 ;
40032 wxMenu *arg5 = (wxMenu *) 0 ;
40033 wxString const &arg6_defvalue = wxPyEmptyString ;
40034 wxString *arg6 = (wxString *) &arg6_defvalue ;
40035 wxMenuItem *result = 0 ;
40036 void *argp1 = 0 ;
40037 int res1 = 0 ;
40038 size_t val2 ;
40039 int ecode2 = 0 ;
40040 int val3 ;
40041 int ecode3 = 0 ;
40042 bool temp4 = false ;
40043 void *argp5 = 0 ;
40044 int res5 = 0 ;
40045 bool temp6 = false ;
40046 PyObject * obj0 = 0 ;
40047 PyObject * obj1 = 0 ;
40048 PyObject * obj2 = 0 ;
40049 PyObject * obj3 = 0 ;
40050 PyObject * obj4 = 0 ;
40051 PyObject * obj5 = 0 ;
40052 char * kwnames[] = {
40053 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40054 };
40055
40056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40058 if (!SWIG_IsOK(res1)) {
40059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40060 }
40061 arg1 = reinterpret_cast< wxMenu * >(argp1);
40062 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40063 if (!SWIG_IsOK(ecode2)) {
40064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40065 }
40066 arg2 = static_cast< size_t >(val2);
40067 ecode3 = SWIG_AsVal_int(obj2, &val3);
40068 if (!SWIG_IsOK(ecode3)) {
40069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40070 }
40071 arg3 = static_cast< int >(val3);
40072 {
40073 arg4 = wxString_in_helper(obj3);
40074 if (arg4 == NULL) SWIG_fail;
40075 temp4 = true;
40076 }
40077 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40078 if (!SWIG_IsOK(res5)) {
40079 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40080 }
40081 arg5 = reinterpret_cast< wxMenu * >(argp5);
40082 if (obj5) {
40083 {
40084 arg6 = wxString_in_helper(obj5);
40085 if (arg6 == NULL) SWIG_fail;
40086 temp6 = true;
40087 }
40088 }
40089 {
40090 PyThreadState* __tstate = wxPyBeginAllowThreads();
40091 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40092 wxPyEndAllowThreads(__tstate);
40093 if (PyErr_Occurred()) SWIG_fail;
40094 }
40095 {
40096 resultobj = wxPyMake_wxObject(result, (bool)0);
40097 }
40098 {
40099 if (temp4)
40100 delete arg4;
40101 }
40102 {
40103 if (temp6)
40104 delete arg6;
40105 }
40106 return resultobj;
40107 fail:
40108 {
40109 if (temp4)
40110 delete arg4;
40111 }
40112 {
40113 if (temp6)
40114 delete arg6;
40115 }
40116 return NULL;
40117 }
40118
40119
40120 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40121 PyObject *resultobj = 0;
40122 wxMenu *arg1 = (wxMenu *) 0 ;
40123 int arg2 ;
40124 wxString const &arg3_defvalue = wxPyEmptyString ;
40125 wxString *arg3 = (wxString *) &arg3_defvalue ;
40126 wxString const &arg4_defvalue = wxPyEmptyString ;
40127 wxString *arg4 = (wxString *) &arg4_defvalue ;
40128 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40129 wxMenuItem *result = 0 ;
40130 void *argp1 = 0 ;
40131 int res1 = 0 ;
40132 int val2 ;
40133 int ecode2 = 0 ;
40134 bool temp3 = false ;
40135 bool temp4 = false ;
40136 int val5 ;
40137 int ecode5 = 0 ;
40138 PyObject * obj0 = 0 ;
40139 PyObject * obj1 = 0 ;
40140 PyObject * obj2 = 0 ;
40141 PyObject * obj3 = 0 ;
40142 PyObject * obj4 = 0 ;
40143 char * kwnames[] = {
40144 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40145 };
40146
40147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40149 if (!SWIG_IsOK(res1)) {
40150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40151 }
40152 arg1 = reinterpret_cast< wxMenu * >(argp1);
40153 ecode2 = SWIG_AsVal_int(obj1, &val2);
40154 if (!SWIG_IsOK(ecode2)) {
40155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40156 }
40157 arg2 = static_cast< int >(val2);
40158 if (obj2) {
40159 {
40160 arg3 = wxString_in_helper(obj2);
40161 if (arg3 == NULL) SWIG_fail;
40162 temp3 = true;
40163 }
40164 }
40165 if (obj3) {
40166 {
40167 arg4 = wxString_in_helper(obj3);
40168 if (arg4 == NULL) SWIG_fail;
40169 temp4 = true;
40170 }
40171 }
40172 if (obj4) {
40173 ecode5 = SWIG_AsVal_int(obj4, &val5);
40174 if (!SWIG_IsOK(ecode5)) {
40175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40176 }
40177 arg5 = static_cast< wxItemKind >(val5);
40178 }
40179 {
40180 PyThreadState* __tstate = wxPyBeginAllowThreads();
40181 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 {
40186 resultobj = wxPyMake_wxObject(result, (bool)0);
40187 }
40188 {
40189 if (temp3)
40190 delete arg3;
40191 }
40192 {
40193 if (temp4)
40194 delete arg4;
40195 }
40196 return resultobj;
40197 fail:
40198 {
40199 if (temp3)
40200 delete arg3;
40201 }
40202 {
40203 if (temp4)
40204 delete arg4;
40205 }
40206 return NULL;
40207 }
40208
40209
40210 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40211 PyObject *resultobj = 0;
40212 wxMenu *arg1 = (wxMenu *) 0 ;
40213 wxMenuItem *result = 0 ;
40214 void *argp1 = 0 ;
40215 int res1 = 0 ;
40216 PyObject *swig_obj[1] ;
40217
40218 if (!args) SWIG_fail;
40219 swig_obj[0] = args;
40220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40221 if (!SWIG_IsOK(res1)) {
40222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40223 }
40224 arg1 = reinterpret_cast< wxMenu * >(argp1);
40225 {
40226 PyThreadState* __tstate = wxPyBeginAllowThreads();
40227 result = (wxMenuItem *)(arg1)->PrependSeparator();
40228 wxPyEndAllowThreads(__tstate);
40229 if (PyErr_Occurred()) SWIG_fail;
40230 }
40231 {
40232 resultobj = wxPyMake_wxObject(result, (bool)0);
40233 }
40234 return resultobj;
40235 fail:
40236 return NULL;
40237 }
40238
40239
40240 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40241 PyObject *resultobj = 0;
40242 wxMenu *arg1 = (wxMenu *) 0 ;
40243 int arg2 ;
40244 wxString *arg3 = 0 ;
40245 wxString const &arg4_defvalue = wxPyEmptyString ;
40246 wxString *arg4 = (wxString *) &arg4_defvalue ;
40247 wxMenuItem *result = 0 ;
40248 void *argp1 = 0 ;
40249 int res1 = 0 ;
40250 int val2 ;
40251 int ecode2 = 0 ;
40252 bool temp3 = false ;
40253 bool temp4 = false ;
40254 PyObject * obj0 = 0 ;
40255 PyObject * obj1 = 0 ;
40256 PyObject * obj2 = 0 ;
40257 PyObject * obj3 = 0 ;
40258 char * kwnames[] = {
40259 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40260 };
40261
40262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40264 if (!SWIG_IsOK(res1)) {
40265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40266 }
40267 arg1 = reinterpret_cast< wxMenu * >(argp1);
40268 ecode2 = SWIG_AsVal_int(obj1, &val2);
40269 if (!SWIG_IsOK(ecode2)) {
40270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40271 }
40272 arg2 = static_cast< int >(val2);
40273 {
40274 arg3 = wxString_in_helper(obj2);
40275 if (arg3 == NULL) SWIG_fail;
40276 temp3 = true;
40277 }
40278 if (obj3) {
40279 {
40280 arg4 = wxString_in_helper(obj3);
40281 if (arg4 == NULL) SWIG_fail;
40282 temp4 = true;
40283 }
40284 }
40285 {
40286 PyThreadState* __tstate = wxPyBeginAllowThreads();
40287 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40288 wxPyEndAllowThreads(__tstate);
40289 if (PyErr_Occurred()) SWIG_fail;
40290 }
40291 {
40292 resultobj = wxPyMake_wxObject(result, (bool)0);
40293 }
40294 {
40295 if (temp3)
40296 delete arg3;
40297 }
40298 {
40299 if (temp4)
40300 delete arg4;
40301 }
40302 return resultobj;
40303 fail:
40304 {
40305 if (temp3)
40306 delete arg3;
40307 }
40308 {
40309 if (temp4)
40310 delete arg4;
40311 }
40312 return NULL;
40313 }
40314
40315
40316 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj = 0;
40318 wxMenu *arg1 = (wxMenu *) 0 ;
40319 int arg2 ;
40320 wxString *arg3 = 0 ;
40321 wxString const &arg4_defvalue = wxPyEmptyString ;
40322 wxString *arg4 = (wxString *) &arg4_defvalue ;
40323 wxMenuItem *result = 0 ;
40324 void *argp1 = 0 ;
40325 int res1 = 0 ;
40326 int val2 ;
40327 int ecode2 = 0 ;
40328 bool temp3 = false ;
40329 bool temp4 = false ;
40330 PyObject * obj0 = 0 ;
40331 PyObject * obj1 = 0 ;
40332 PyObject * obj2 = 0 ;
40333 PyObject * obj3 = 0 ;
40334 char * kwnames[] = {
40335 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40336 };
40337
40338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40340 if (!SWIG_IsOK(res1)) {
40341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40342 }
40343 arg1 = reinterpret_cast< wxMenu * >(argp1);
40344 ecode2 = SWIG_AsVal_int(obj1, &val2);
40345 if (!SWIG_IsOK(ecode2)) {
40346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40347 }
40348 arg2 = static_cast< int >(val2);
40349 {
40350 arg3 = wxString_in_helper(obj2);
40351 if (arg3 == NULL) SWIG_fail;
40352 temp3 = true;
40353 }
40354 if (obj3) {
40355 {
40356 arg4 = wxString_in_helper(obj3);
40357 if (arg4 == NULL) SWIG_fail;
40358 temp4 = true;
40359 }
40360 }
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 {
40368 resultobj = wxPyMake_wxObject(result, (bool)0);
40369 }
40370 {
40371 if (temp3)
40372 delete arg3;
40373 }
40374 {
40375 if (temp4)
40376 delete arg4;
40377 }
40378 return resultobj;
40379 fail:
40380 {
40381 if (temp3)
40382 delete arg3;
40383 }
40384 {
40385 if (temp4)
40386 delete arg4;
40387 }
40388 return NULL;
40389 }
40390
40391
40392 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40393 PyObject *resultobj = 0;
40394 wxMenu *arg1 = (wxMenu *) 0 ;
40395 int arg2 ;
40396 wxString *arg3 = 0 ;
40397 wxMenu *arg4 = (wxMenu *) 0 ;
40398 wxString const &arg5_defvalue = wxPyEmptyString ;
40399 wxString *arg5 = (wxString *) &arg5_defvalue ;
40400 wxMenuItem *result = 0 ;
40401 void *argp1 = 0 ;
40402 int res1 = 0 ;
40403 int val2 ;
40404 int ecode2 = 0 ;
40405 bool temp3 = false ;
40406 void *argp4 = 0 ;
40407 int res4 = 0 ;
40408 bool temp5 = false ;
40409 PyObject * obj0 = 0 ;
40410 PyObject * obj1 = 0 ;
40411 PyObject * obj2 = 0 ;
40412 PyObject * obj3 = 0 ;
40413 PyObject * obj4 = 0 ;
40414 char * kwnames[] = {
40415 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40416 };
40417
40418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40420 if (!SWIG_IsOK(res1)) {
40421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40422 }
40423 arg1 = reinterpret_cast< wxMenu * >(argp1);
40424 ecode2 = SWIG_AsVal_int(obj1, &val2);
40425 if (!SWIG_IsOK(ecode2)) {
40426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40427 }
40428 arg2 = static_cast< int >(val2);
40429 {
40430 arg3 = wxString_in_helper(obj2);
40431 if (arg3 == NULL) SWIG_fail;
40432 temp3 = true;
40433 }
40434 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40435 if (!SWIG_IsOK(res4)) {
40436 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40437 }
40438 arg4 = reinterpret_cast< wxMenu * >(argp4);
40439 if (obj4) {
40440 {
40441 arg5 = wxString_in_helper(obj4);
40442 if (arg5 == NULL) SWIG_fail;
40443 temp5 = true;
40444 }
40445 }
40446 {
40447 PyThreadState* __tstate = wxPyBeginAllowThreads();
40448 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40449 wxPyEndAllowThreads(__tstate);
40450 if (PyErr_Occurred()) SWIG_fail;
40451 }
40452 {
40453 resultobj = wxPyMake_wxObject(result, (bool)0);
40454 }
40455 {
40456 if (temp3)
40457 delete arg3;
40458 }
40459 {
40460 if (temp5)
40461 delete arg5;
40462 }
40463 return resultobj;
40464 fail:
40465 {
40466 if (temp3)
40467 delete arg3;
40468 }
40469 {
40470 if (temp5)
40471 delete arg5;
40472 }
40473 return NULL;
40474 }
40475
40476
40477 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40478 PyObject *resultobj = 0;
40479 wxMenu *arg1 = (wxMenu *) 0 ;
40480 int arg2 ;
40481 wxMenuItem *result = 0 ;
40482 void *argp1 = 0 ;
40483 int res1 = 0 ;
40484 int val2 ;
40485 int ecode2 = 0 ;
40486 PyObject * obj0 = 0 ;
40487 PyObject * obj1 = 0 ;
40488 char * kwnames[] = {
40489 (char *) "self",(char *) "id", NULL
40490 };
40491
40492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40494 if (!SWIG_IsOK(res1)) {
40495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40496 }
40497 arg1 = reinterpret_cast< wxMenu * >(argp1);
40498 ecode2 = SWIG_AsVal_int(obj1, &val2);
40499 if (!SWIG_IsOK(ecode2)) {
40500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40501 }
40502 arg2 = static_cast< int >(val2);
40503 {
40504 PyThreadState* __tstate = wxPyBeginAllowThreads();
40505 result = (wxMenuItem *)(arg1)->Remove(arg2);
40506 wxPyEndAllowThreads(__tstate);
40507 if (PyErr_Occurred()) SWIG_fail;
40508 }
40509 {
40510 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40511 }
40512 return resultobj;
40513 fail:
40514 return NULL;
40515 }
40516
40517
40518 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40519 PyObject *resultobj = 0;
40520 wxMenu *arg1 = (wxMenu *) 0 ;
40521 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40522 wxMenuItem *result = 0 ;
40523 void *argp1 = 0 ;
40524 int res1 = 0 ;
40525 void *argp2 = 0 ;
40526 int res2 = 0 ;
40527 PyObject * obj0 = 0 ;
40528 PyObject * obj1 = 0 ;
40529 char * kwnames[] = {
40530 (char *) "self",(char *) "item", NULL
40531 };
40532
40533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40535 if (!SWIG_IsOK(res1)) {
40536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40537 }
40538 arg1 = reinterpret_cast< wxMenu * >(argp1);
40539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40540 if (!SWIG_IsOK(res2)) {
40541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40542 }
40543 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40544 {
40545 PyThreadState* __tstate = wxPyBeginAllowThreads();
40546 result = (wxMenuItem *)(arg1)->Remove(arg2);
40547 wxPyEndAllowThreads(__tstate);
40548 if (PyErr_Occurred()) SWIG_fail;
40549 }
40550 {
40551 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40552 }
40553 return resultobj;
40554 fail:
40555 return NULL;
40556 }
40557
40558
40559 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40560 PyObject *resultobj = 0;
40561 wxMenu *arg1 = (wxMenu *) 0 ;
40562 int arg2 ;
40563 bool result;
40564 void *argp1 = 0 ;
40565 int res1 = 0 ;
40566 int val2 ;
40567 int ecode2 = 0 ;
40568 PyObject * obj0 = 0 ;
40569 PyObject * obj1 = 0 ;
40570 char * kwnames[] = {
40571 (char *) "self",(char *) "id", NULL
40572 };
40573
40574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40576 if (!SWIG_IsOK(res1)) {
40577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40578 }
40579 arg1 = reinterpret_cast< wxMenu * >(argp1);
40580 ecode2 = SWIG_AsVal_int(obj1, &val2);
40581 if (!SWIG_IsOK(ecode2)) {
40582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40583 }
40584 arg2 = static_cast< int >(val2);
40585 {
40586 PyThreadState* __tstate = wxPyBeginAllowThreads();
40587 result = (bool)(arg1)->Delete(arg2);
40588 wxPyEndAllowThreads(__tstate);
40589 if (PyErr_Occurred()) SWIG_fail;
40590 }
40591 {
40592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40593 }
40594 return resultobj;
40595 fail:
40596 return NULL;
40597 }
40598
40599
40600 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40601 PyObject *resultobj = 0;
40602 wxMenu *arg1 = (wxMenu *) 0 ;
40603 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40604 bool result;
40605 void *argp1 = 0 ;
40606 int res1 = 0 ;
40607 void *argp2 = 0 ;
40608 int res2 = 0 ;
40609 PyObject * obj0 = 0 ;
40610 PyObject * obj1 = 0 ;
40611 char * kwnames[] = {
40612 (char *) "self",(char *) "item", NULL
40613 };
40614
40615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40617 if (!SWIG_IsOK(res1)) {
40618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40619 }
40620 arg1 = reinterpret_cast< wxMenu * >(argp1);
40621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40622 if (!SWIG_IsOK(res2)) {
40623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40624 }
40625 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 result = (bool)(arg1)->Delete(arg2);
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 {
40633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40634 }
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40642 PyObject *resultobj = 0;
40643 wxMenu *arg1 = (wxMenu *) 0 ;
40644 void *argp1 = 0 ;
40645 int res1 = 0 ;
40646 PyObject *swig_obj[1] ;
40647
40648 if (!args) SWIG_fail;
40649 swig_obj[0] = args;
40650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40651 if (!SWIG_IsOK(res1)) {
40652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40653 }
40654 arg1 = reinterpret_cast< wxMenu * >(argp1);
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 wxMenu_Destroy(arg1);
40658 wxPyEndAllowThreads(__tstate);
40659 if (PyErr_Occurred()) SWIG_fail;
40660 }
40661 resultobj = SWIG_Py_Void();
40662 return resultobj;
40663 fail:
40664 return NULL;
40665 }
40666
40667
40668 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40669 PyObject *resultobj = 0;
40670 wxMenu *arg1 = (wxMenu *) 0 ;
40671 int arg2 ;
40672 bool result;
40673 void *argp1 = 0 ;
40674 int res1 = 0 ;
40675 int val2 ;
40676 int ecode2 = 0 ;
40677 PyObject * obj0 = 0 ;
40678 PyObject * obj1 = 0 ;
40679 char * kwnames[] = {
40680 (char *) "self",(char *) "id", NULL
40681 };
40682
40683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40685 if (!SWIG_IsOK(res1)) {
40686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40687 }
40688 arg1 = reinterpret_cast< wxMenu * >(argp1);
40689 ecode2 = SWIG_AsVal_int(obj1, &val2);
40690 if (!SWIG_IsOK(ecode2)) {
40691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40692 }
40693 arg2 = static_cast< int >(val2);
40694 {
40695 PyThreadState* __tstate = wxPyBeginAllowThreads();
40696 result = (bool)(arg1)->Destroy(arg2);
40697 wxPyEndAllowThreads(__tstate);
40698 if (PyErr_Occurred()) SWIG_fail;
40699 }
40700 {
40701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40702 }
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40710 PyObject *resultobj = 0;
40711 wxMenu *arg1 = (wxMenu *) 0 ;
40712 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40713 bool result;
40714 void *argp1 = 0 ;
40715 int res1 = 0 ;
40716 void *argp2 = 0 ;
40717 int res2 = 0 ;
40718 PyObject * obj0 = 0 ;
40719 PyObject * obj1 = 0 ;
40720 char * kwnames[] = {
40721 (char *) "self",(char *) "item", NULL
40722 };
40723
40724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",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_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40728 }
40729 arg1 = reinterpret_cast< wxMenu * >(argp1);
40730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40731 if (!SWIG_IsOK(res2)) {
40732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40733 }
40734 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40735 {
40736 PyThreadState* __tstate = wxPyBeginAllowThreads();
40737 result = (bool)(arg1)->Destroy(arg2);
40738 wxPyEndAllowThreads(__tstate);
40739 if (PyErr_Occurred()) SWIG_fail;
40740 }
40741 {
40742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40743 }
40744 return resultobj;
40745 fail:
40746 return NULL;
40747 }
40748
40749
40750 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40751 PyObject *resultobj = 0;
40752 wxMenu *arg1 = (wxMenu *) 0 ;
40753 size_t result;
40754 void *argp1 = 0 ;
40755 int res1 = 0 ;
40756 PyObject *swig_obj[1] ;
40757
40758 if (!args) SWIG_fail;
40759 swig_obj[0] = args;
40760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40761 if (!SWIG_IsOK(res1)) {
40762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40763 }
40764 arg1 = reinterpret_cast< wxMenu * >(argp1);
40765 {
40766 PyThreadState* __tstate = wxPyBeginAllowThreads();
40767 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40768 wxPyEndAllowThreads(__tstate);
40769 if (PyErr_Occurred()) SWIG_fail;
40770 }
40771 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40772 return resultobj;
40773 fail:
40774 return NULL;
40775 }
40776
40777
40778 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40779 PyObject *resultobj = 0;
40780 wxMenu *arg1 = (wxMenu *) 0 ;
40781 PyObject *result = 0 ;
40782 void *argp1 = 0 ;
40783 int res1 = 0 ;
40784 PyObject *swig_obj[1] ;
40785
40786 if (!args) SWIG_fail;
40787 swig_obj[0] = args;
40788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40789 if (!SWIG_IsOK(res1)) {
40790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40791 }
40792 arg1 = reinterpret_cast< wxMenu * >(argp1);
40793 {
40794 PyThreadState* __tstate = wxPyBeginAllowThreads();
40795 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40796 wxPyEndAllowThreads(__tstate);
40797 if (PyErr_Occurred()) SWIG_fail;
40798 }
40799 resultobj = result;
40800 return resultobj;
40801 fail:
40802 return NULL;
40803 }
40804
40805
40806 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40807 PyObject *resultobj = 0;
40808 wxMenu *arg1 = (wxMenu *) 0 ;
40809 wxString *arg2 = 0 ;
40810 int result;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 bool temp2 = false ;
40814 PyObject * obj0 = 0 ;
40815 PyObject * obj1 = 0 ;
40816 char * kwnames[] = {
40817 (char *) "self",(char *) "item", NULL
40818 };
40819
40820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40822 if (!SWIG_IsOK(res1)) {
40823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40824 }
40825 arg1 = reinterpret_cast< wxMenu * >(argp1);
40826 {
40827 arg2 = wxString_in_helper(obj1);
40828 if (arg2 == NULL) SWIG_fail;
40829 temp2 = true;
40830 }
40831 {
40832 PyThreadState* __tstate = wxPyBeginAllowThreads();
40833 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40834 wxPyEndAllowThreads(__tstate);
40835 if (PyErr_Occurred()) SWIG_fail;
40836 }
40837 resultobj = SWIG_From_int(static_cast< int >(result));
40838 {
40839 if (temp2)
40840 delete arg2;
40841 }
40842 return resultobj;
40843 fail:
40844 {
40845 if (temp2)
40846 delete arg2;
40847 }
40848 return NULL;
40849 }
40850
40851
40852 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40853 PyObject *resultobj = 0;
40854 wxMenu *arg1 = (wxMenu *) 0 ;
40855 int arg2 ;
40856 wxMenuItem *result = 0 ;
40857 void *argp1 = 0 ;
40858 int res1 = 0 ;
40859 int val2 ;
40860 int ecode2 = 0 ;
40861 PyObject * obj0 = 0 ;
40862 PyObject * obj1 = 0 ;
40863 char * kwnames[] = {
40864 (char *) "self",(char *) "id", NULL
40865 };
40866
40867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40869 if (!SWIG_IsOK(res1)) {
40870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40871 }
40872 arg1 = reinterpret_cast< wxMenu * >(argp1);
40873 ecode2 = SWIG_AsVal_int(obj1, &val2);
40874 if (!SWIG_IsOK(ecode2)) {
40875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40876 }
40877 arg2 = static_cast< int >(val2);
40878 {
40879 PyThreadState* __tstate = wxPyBeginAllowThreads();
40880 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40881 wxPyEndAllowThreads(__tstate);
40882 if (PyErr_Occurred()) SWIG_fail;
40883 }
40884 {
40885 resultobj = wxPyMake_wxObject(result, (bool)0);
40886 }
40887 return resultobj;
40888 fail:
40889 return NULL;
40890 }
40891
40892
40893 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40894 PyObject *resultobj = 0;
40895 wxMenu *arg1 = (wxMenu *) 0 ;
40896 size_t arg2 ;
40897 wxMenuItem *result = 0 ;
40898 void *argp1 = 0 ;
40899 int res1 = 0 ;
40900 size_t val2 ;
40901 int ecode2 = 0 ;
40902 PyObject * obj0 = 0 ;
40903 PyObject * obj1 = 0 ;
40904 char * kwnames[] = {
40905 (char *) "self",(char *) "position", NULL
40906 };
40907
40908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40910 if (!SWIG_IsOK(res1)) {
40911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40912 }
40913 arg1 = reinterpret_cast< wxMenu * >(argp1);
40914 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40915 if (!SWIG_IsOK(ecode2)) {
40916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40917 }
40918 arg2 = static_cast< size_t >(val2);
40919 {
40920 PyThreadState* __tstate = wxPyBeginAllowThreads();
40921 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40922 wxPyEndAllowThreads(__tstate);
40923 if (PyErr_Occurred()) SWIG_fail;
40924 }
40925 {
40926 resultobj = wxPyMake_wxObject(result, (bool)0);
40927 }
40928 return resultobj;
40929 fail:
40930 return NULL;
40931 }
40932
40933
40934 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40935 PyObject *resultobj = 0;
40936 wxMenu *arg1 = (wxMenu *) 0 ;
40937 int arg2 ;
40938 bool arg3 ;
40939 void *argp1 = 0 ;
40940 int res1 = 0 ;
40941 int val2 ;
40942 int ecode2 = 0 ;
40943 bool val3 ;
40944 int ecode3 = 0 ;
40945 PyObject * obj0 = 0 ;
40946 PyObject * obj1 = 0 ;
40947 PyObject * obj2 = 0 ;
40948 char * kwnames[] = {
40949 (char *) "self",(char *) "id",(char *) "enable", NULL
40950 };
40951
40952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40954 if (!SWIG_IsOK(res1)) {
40955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40956 }
40957 arg1 = reinterpret_cast< wxMenu * >(argp1);
40958 ecode2 = SWIG_AsVal_int(obj1, &val2);
40959 if (!SWIG_IsOK(ecode2)) {
40960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40961 }
40962 arg2 = static_cast< int >(val2);
40963 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40964 if (!SWIG_IsOK(ecode3)) {
40965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40966 }
40967 arg3 = static_cast< bool >(val3);
40968 {
40969 PyThreadState* __tstate = wxPyBeginAllowThreads();
40970 (arg1)->Enable(arg2,arg3);
40971 wxPyEndAllowThreads(__tstate);
40972 if (PyErr_Occurred()) SWIG_fail;
40973 }
40974 resultobj = SWIG_Py_Void();
40975 return resultobj;
40976 fail:
40977 return NULL;
40978 }
40979
40980
40981 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40982 PyObject *resultobj = 0;
40983 wxMenu *arg1 = (wxMenu *) 0 ;
40984 int arg2 ;
40985 bool result;
40986 void *argp1 = 0 ;
40987 int res1 = 0 ;
40988 int val2 ;
40989 int ecode2 = 0 ;
40990 PyObject * obj0 = 0 ;
40991 PyObject * obj1 = 0 ;
40992 char * kwnames[] = {
40993 (char *) "self",(char *) "id", NULL
40994 };
40995
40996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40998 if (!SWIG_IsOK(res1)) {
40999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41000 }
41001 arg1 = reinterpret_cast< wxMenu * >(argp1);
41002 ecode2 = SWIG_AsVal_int(obj1, &val2);
41003 if (!SWIG_IsOK(ecode2)) {
41004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41005 }
41006 arg2 = static_cast< int >(val2);
41007 {
41008 PyThreadState* __tstate = wxPyBeginAllowThreads();
41009 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41010 wxPyEndAllowThreads(__tstate);
41011 if (PyErr_Occurred()) SWIG_fail;
41012 }
41013 {
41014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41015 }
41016 return resultobj;
41017 fail:
41018 return NULL;
41019 }
41020
41021
41022 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41023 PyObject *resultobj = 0;
41024 wxMenu *arg1 = (wxMenu *) 0 ;
41025 int arg2 ;
41026 bool arg3 ;
41027 void *argp1 = 0 ;
41028 int res1 = 0 ;
41029 int val2 ;
41030 int ecode2 = 0 ;
41031 bool val3 ;
41032 int ecode3 = 0 ;
41033 PyObject * obj0 = 0 ;
41034 PyObject * obj1 = 0 ;
41035 PyObject * obj2 = 0 ;
41036 char * kwnames[] = {
41037 (char *) "self",(char *) "id",(char *) "check", NULL
41038 };
41039
41040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41042 if (!SWIG_IsOK(res1)) {
41043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41044 }
41045 arg1 = reinterpret_cast< wxMenu * >(argp1);
41046 ecode2 = SWIG_AsVal_int(obj1, &val2);
41047 if (!SWIG_IsOK(ecode2)) {
41048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41049 }
41050 arg2 = static_cast< int >(val2);
41051 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41052 if (!SWIG_IsOK(ecode3)) {
41053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41054 }
41055 arg3 = static_cast< bool >(val3);
41056 {
41057 PyThreadState* __tstate = wxPyBeginAllowThreads();
41058 (arg1)->Check(arg2,arg3);
41059 wxPyEndAllowThreads(__tstate);
41060 if (PyErr_Occurred()) SWIG_fail;
41061 }
41062 resultobj = SWIG_Py_Void();
41063 return resultobj;
41064 fail:
41065 return NULL;
41066 }
41067
41068
41069 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41070 PyObject *resultobj = 0;
41071 wxMenu *arg1 = (wxMenu *) 0 ;
41072 int arg2 ;
41073 bool result;
41074 void *argp1 = 0 ;
41075 int res1 = 0 ;
41076 int val2 ;
41077 int ecode2 = 0 ;
41078 PyObject * obj0 = 0 ;
41079 PyObject * obj1 = 0 ;
41080 char * kwnames[] = {
41081 (char *) "self",(char *) "id", NULL
41082 };
41083
41084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41086 if (!SWIG_IsOK(res1)) {
41087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41088 }
41089 arg1 = reinterpret_cast< wxMenu * >(argp1);
41090 ecode2 = SWIG_AsVal_int(obj1, &val2);
41091 if (!SWIG_IsOK(ecode2)) {
41092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41093 }
41094 arg2 = static_cast< int >(val2);
41095 {
41096 PyThreadState* __tstate = wxPyBeginAllowThreads();
41097 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41098 wxPyEndAllowThreads(__tstate);
41099 if (PyErr_Occurred()) SWIG_fail;
41100 }
41101 {
41102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41103 }
41104 return resultobj;
41105 fail:
41106 return NULL;
41107 }
41108
41109
41110 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41111 PyObject *resultobj = 0;
41112 wxMenu *arg1 = (wxMenu *) 0 ;
41113 int arg2 ;
41114 wxString *arg3 = 0 ;
41115 void *argp1 = 0 ;
41116 int res1 = 0 ;
41117 int val2 ;
41118 int ecode2 = 0 ;
41119 bool temp3 = false ;
41120 PyObject * obj0 = 0 ;
41121 PyObject * obj1 = 0 ;
41122 PyObject * obj2 = 0 ;
41123 char * kwnames[] = {
41124 (char *) "self",(char *) "id",(char *) "label", NULL
41125 };
41126
41127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41129 if (!SWIG_IsOK(res1)) {
41130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41131 }
41132 arg1 = reinterpret_cast< wxMenu * >(argp1);
41133 ecode2 = SWIG_AsVal_int(obj1, &val2);
41134 if (!SWIG_IsOK(ecode2)) {
41135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41136 }
41137 arg2 = static_cast< int >(val2);
41138 {
41139 arg3 = wxString_in_helper(obj2);
41140 if (arg3 == NULL) SWIG_fail;
41141 temp3 = true;
41142 }
41143 {
41144 PyThreadState* __tstate = wxPyBeginAllowThreads();
41145 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41146 wxPyEndAllowThreads(__tstate);
41147 if (PyErr_Occurred()) SWIG_fail;
41148 }
41149 resultobj = SWIG_Py_Void();
41150 {
41151 if (temp3)
41152 delete arg3;
41153 }
41154 return resultobj;
41155 fail:
41156 {
41157 if (temp3)
41158 delete arg3;
41159 }
41160 return NULL;
41161 }
41162
41163
41164 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41165 PyObject *resultobj = 0;
41166 wxMenu *arg1 = (wxMenu *) 0 ;
41167 int arg2 ;
41168 wxString result;
41169 void *argp1 = 0 ;
41170 int res1 = 0 ;
41171 int val2 ;
41172 int ecode2 = 0 ;
41173 PyObject * obj0 = 0 ;
41174 PyObject * obj1 = 0 ;
41175 char * kwnames[] = {
41176 (char *) "self",(char *) "id", NULL
41177 };
41178
41179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41181 if (!SWIG_IsOK(res1)) {
41182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41183 }
41184 arg1 = reinterpret_cast< wxMenu * >(argp1);
41185 ecode2 = SWIG_AsVal_int(obj1, &val2);
41186 if (!SWIG_IsOK(ecode2)) {
41187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41188 }
41189 arg2 = static_cast< int >(val2);
41190 {
41191 PyThreadState* __tstate = wxPyBeginAllowThreads();
41192 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41193 wxPyEndAllowThreads(__tstate);
41194 if (PyErr_Occurred()) SWIG_fail;
41195 }
41196 {
41197 #if wxUSE_UNICODE
41198 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41199 #else
41200 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41201 #endif
41202 }
41203 return resultobj;
41204 fail:
41205 return NULL;
41206 }
41207
41208
41209 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41210 PyObject *resultobj = 0;
41211 wxMenu *arg1 = (wxMenu *) 0 ;
41212 int arg2 ;
41213 wxString *arg3 = 0 ;
41214 void *argp1 = 0 ;
41215 int res1 = 0 ;
41216 int val2 ;
41217 int ecode2 = 0 ;
41218 bool temp3 = false ;
41219 PyObject * obj0 = 0 ;
41220 PyObject * obj1 = 0 ;
41221 PyObject * obj2 = 0 ;
41222 char * kwnames[] = {
41223 (char *) "self",(char *) "id",(char *) "helpString", NULL
41224 };
41225
41226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41228 if (!SWIG_IsOK(res1)) {
41229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41230 }
41231 arg1 = reinterpret_cast< wxMenu * >(argp1);
41232 ecode2 = SWIG_AsVal_int(obj1, &val2);
41233 if (!SWIG_IsOK(ecode2)) {
41234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41235 }
41236 arg2 = static_cast< int >(val2);
41237 {
41238 arg3 = wxString_in_helper(obj2);
41239 if (arg3 == NULL) SWIG_fail;
41240 temp3 = true;
41241 }
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41245 wxPyEndAllowThreads(__tstate);
41246 if (PyErr_Occurred()) SWIG_fail;
41247 }
41248 resultobj = SWIG_Py_Void();
41249 {
41250 if (temp3)
41251 delete arg3;
41252 }
41253 return resultobj;
41254 fail:
41255 {
41256 if (temp3)
41257 delete arg3;
41258 }
41259 return NULL;
41260 }
41261
41262
41263 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41264 PyObject *resultobj = 0;
41265 wxMenu *arg1 = (wxMenu *) 0 ;
41266 int arg2 ;
41267 wxString result;
41268 void *argp1 = 0 ;
41269 int res1 = 0 ;
41270 int val2 ;
41271 int ecode2 = 0 ;
41272 PyObject * obj0 = 0 ;
41273 PyObject * obj1 = 0 ;
41274 char * kwnames[] = {
41275 (char *) "self",(char *) "id", NULL
41276 };
41277
41278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41280 if (!SWIG_IsOK(res1)) {
41281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41282 }
41283 arg1 = reinterpret_cast< wxMenu * >(argp1);
41284 ecode2 = SWIG_AsVal_int(obj1, &val2);
41285 if (!SWIG_IsOK(ecode2)) {
41286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41287 }
41288 arg2 = static_cast< int >(val2);
41289 {
41290 PyThreadState* __tstate = wxPyBeginAllowThreads();
41291 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41292 wxPyEndAllowThreads(__tstate);
41293 if (PyErr_Occurred()) SWIG_fail;
41294 }
41295 {
41296 #if wxUSE_UNICODE
41297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41298 #else
41299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41300 #endif
41301 }
41302 return resultobj;
41303 fail:
41304 return NULL;
41305 }
41306
41307
41308 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41309 PyObject *resultobj = 0;
41310 wxMenu *arg1 = (wxMenu *) 0 ;
41311 wxString *arg2 = 0 ;
41312 void *argp1 = 0 ;
41313 int res1 = 0 ;
41314 bool temp2 = false ;
41315 PyObject * obj0 = 0 ;
41316 PyObject * obj1 = 0 ;
41317 char * kwnames[] = {
41318 (char *) "self",(char *) "title", NULL
41319 };
41320
41321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41323 if (!SWIG_IsOK(res1)) {
41324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41325 }
41326 arg1 = reinterpret_cast< wxMenu * >(argp1);
41327 {
41328 arg2 = wxString_in_helper(obj1);
41329 if (arg2 == NULL) SWIG_fail;
41330 temp2 = true;
41331 }
41332 {
41333 PyThreadState* __tstate = wxPyBeginAllowThreads();
41334 (arg1)->SetTitle((wxString const &)*arg2);
41335 wxPyEndAllowThreads(__tstate);
41336 if (PyErr_Occurred()) SWIG_fail;
41337 }
41338 resultobj = SWIG_Py_Void();
41339 {
41340 if (temp2)
41341 delete arg2;
41342 }
41343 return resultobj;
41344 fail:
41345 {
41346 if (temp2)
41347 delete arg2;
41348 }
41349 return NULL;
41350 }
41351
41352
41353 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41354 PyObject *resultobj = 0;
41355 wxMenu *arg1 = (wxMenu *) 0 ;
41356 wxString result;
41357 void *argp1 = 0 ;
41358 int res1 = 0 ;
41359 PyObject *swig_obj[1] ;
41360
41361 if (!args) SWIG_fail;
41362 swig_obj[0] = args;
41363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41364 if (!SWIG_IsOK(res1)) {
41365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41366 }
41367 arg1 = reinterpret_cast< wxMenu * >(argp1);
41368 {
41369 PyThreadState* __tstate = wxPyBeginAllowThreads();
41370 result = ((wxMenu const *)arg1)->GetTitle();
41371 wxPyEndAllowThreads(__tstate);
41372 if (PyErr_Occurred()) SWIG_fail;
41373 }
41374 {
41375 #if wxUSE_UNICODE
41376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41377 #else
41378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41379 #endif
41380 }
41381 return resultobj;
41382 fail:
41383 return NULL;
41384 }
41385
41386
41387 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41388 PyObject *resultobj = 0;
41389 wxMenu *arg1 = (wxMenu *) 0 ;
41390 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41391 void *argp1 = 0 ;
41392 int res1 = 0 ;
41393 void *argp2 = 0 ;
41394 int res2 = 0 ;
41395 PyObject * obj0 = 0 ;
41396 PyObject * obj1 = 0 ;
41397 char * kwnames[] = {
41398 (char *) "self",(char *) "handler", NULL
41399 };
41400
41401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41403 if (!SWIG_IsOK(res1)) {
41404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41405 }
41406 arg1 = reinterpret_cast< wxMenu * >(argp1);
41407 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41408 if (!SWIG_IsOK(res2)) {
41409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41410 }
41411 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41412 {
41413 PyThreadState* __tstate = wxPyBeginAllowThreads();
41414 (arg1)->SetEventHandler(arg2);
41415 wxPyEndAllowThreads(__tstate);
41416 if (PyErr_Occurred()) SWIG_fail;
41417 }
41418 resultobj = SWIG_Py_Void();
41419 return resultobj;
41420 fail:
41421 return NULL;
41422 }
41423
41424
41425 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41426 PyObject *resultobj = 0;
41427 wxMenu *arg1 = (wxMenu *) 0 ;
41428 wxEvtHandler *result = 0 ;
41429 void *argp1 = 0 ;
41430 int res1 = 0 ;
41431 PyObject *swig_obj[1] ;
41432
41433 if (!args) SWIG_fail;
41434 swig_obj[0] = args;
41435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41436 if (!SWIG_IsOK(res1)) {
41437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41438 }
41439 arg1 = reinterpret_cast< wxMenu * >(argp1);
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41443 wxPyEndAllowThreads(__tstate);
41444 if (PyErr_Occurred()) SWIG_fail;
41445 }
41446 {
41447 resultobj = wxPyMake_wxObject(result, 0);
41448 }
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj = 0;
41457 wxMenu *arg1 = (wxMenu *) 0 ;
41458 wxWindow *arg2 = (wxWindow *) 0 ;
41459 void *argp1 = 0 ;
41460 int res1 = 0 ;
41461 void *argp2 = 0 ;
41462 int res2 = 0 ;
41463 PyObject * obj0 = 0 ;
41464 PyObject * obj1 = 0 ;
41465 char * kwnames[] = {
41466 (char *) "self",(char *) "win", NULL
41467 };
41468
41469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41471 if (!SWIG_IsOK(res1)) {
41472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41473 }
41474 arg1 = reinterpret_cast< wxMenu * >(argp1);
41475 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41476 if (!SWIG_IsOK(res2)) {
41477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41478 }
41479 arg2 = reinterpret_cast< wxWindow * >(argp2);
41480 {
41481 PyThreadState* __tstate = wxPyBeginAllowThreads();
41482 (arg1)->SetInvokingWindow(arg2);
41483 wxPyEndAllowThreads(__tstate);
41484 if (PyErr_Occurred()) SWIG_fail;
41485 }
41486 resultobj = SWIG_Py_Void();
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41494 PyObject *resultobj = 0;
41495 wxMenu *arg1 = (wxMenu *) 0 ;
41496 wxWindow *result = 0 ;
41497 void *argp1 = 0 ;
41498 int res1 = 0 ;
41499 PyObject *swig_obj[1] ;
41500
41501 if (!args) SWIG_fail;
41502 swig_obj[0] = args;
41503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41504 if (!SWIG_IsOK(res1)) {
41505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41506 }
41507 arg1 = reinterpret_cast< wxMenu * >(argp1);
41508 {
41509 PyThreadState* __tstate = wxPyBeginAllowThreads();
41510 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41511 wxPyEndAllowThreads(__tstate);
41512 if (PyErr_Occurred()) SWIG_fail;
41513 }
41514 {
41515 resultobj = wxPyMake_wxObject(result, 0);
41516 }
41517 return resultobj;
41518 fail:
41519 return NULL;
41520 }
41521
41522
41523 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41524 PyObject *resultobj = 0;
41525 wxMenu *arg1 = (wxMenu *) 0 ;
41526 long result;
41527 void *argp1 = 0 ;
41528 int res1 = 0 ;
41529 PyObject *swig_obj[1] ;
41530
41531 if (!args) SWIG_fail;
41532 swig_obj[0] = args;
41533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41534 if (!SWIG_IsOK(res1)) {
41535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41536 }
41537 arg1 = reinterpret_cast< wxMenu * >(argp1);
41538 {
41539 PyThreadState* __tstate = wxPyBeginAllowThreads();
41540 result = (long)((wxMenu const *)arg1)->GetStyle();
41541 wxPyEndAllowThreads(__tstate);
41542 if (PyErr_Occurred()) SWIG_fail;
41543 }
41544 resultobj = SWIG_From_long(static_cast< long >(result));
41545 return resultobj;
41546 fail:
41547 return NULL;
41548 }
41549
41550
41551 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41552 PyObject *resultobj = 0;
41553 wxMenu *arg1 = (wxMenu *) 0 ;
41554 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41555 void *argp1 = 0 ;
41556 int res1 = 0 ;
41557 void *argp2 = 0 ;
41558 int res2 = 0 ;
41559 PyObject * obj0 = 0 ;
41560 PyObject * obj1 = 0 ;
41561 char * kwnames[] = {
41562 (char *) "self",(char *) "source", NULL
41563 };
41564
41565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41567 if (!SWIG_IsOK(res1)) {
41568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41569 }
41570 arg1 = reinterpret_cast< wxMenu * >(argp1);
41571 if (obj1) {
41572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41573 if (!SWIG_IsOK(res2)) {
41574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41575 }
41576 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41577 }
41578 {
41579 PyThreadState* __tstate = wxPyBeginAllowThreads();
41580 (arg1)->UpdateUI(arg2);
41581 wxPyEndAllowThreads(__tstate);
41582 if (PyErr_Occurred()) SWIG_fail;
41583 }
41584 resultobj = SWIG_Py_Void();
41585 return resultobj;
41586 fail:
41587 return NULL;
41588 }
41589
41590
41591 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41592 PyObject *resultobj = 0;
41593 wxMenu *arg1 = (wxMenu *) 0 ;
41594 wxMenuBar *result = 0 ;
41595 void *argp1 = 0 ;
41596 int res1 = 0 ;
41597 PyObject *swig_obj[1] ;
41598
41599 if (!args) SWIG_fail;
41600 swig_obj[0] = args;
41601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41602 if (!SWIG_IsOK(res1)) {
41603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41604 }
41605 arg1 = reinterpret_cast< wxMenu * >(argp1);
41606 {
41607 PyThreadState* __tstate = wxPyBeginAllowThreads();
41608 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41609 wxPyEndAllowThreads(__tstate);
41610 if (PyErr_Occurred()) SWIG_fail;
41611 }
41612 {
41613 resultobj = wxPyMake_wxObject(result, (bool)0);
41614 }
41615 return resultobj;
41616 fail:
41617 return NULL;
41618 }
41619
41620
41621 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41622 PyObject *resultobj = 0;
41623 wxMenu *arg1 = (wxMenu *) 0 ;
41624 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41625 void *argp1 = 0 ;
41626 int res1 = 0 ;
41627 void *argp2 = 0 ;
41628 int res2 = 0 ;
41629 PyObject * obj0 = 0 ;
41630 PyObject * obj1 = 0 ;
41631 char * kwnames[] = {
41632 (char *) "self",(char *) "menubar", NULL
41633 };
41634
41635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41639 }
41640 arg1 = reinterpret_cast< wxMenu * >(argp1);
41641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41642 if (!SWIG_IsOK(res2)) {
41643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41644 }
41645 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41646 {
41647 PyThreadState* __tstate = wxPyBeginAllowThreads();
41648 (arg1)->Attach(arg2);
41649 wxPyEndAllowThreads(__tstate);
41650 if (PyErr_Occurred()) SWIG_fail;
41651 }
41652 resultobj = SWIG_Py_Void();
41653 return resultobj;
41654 fail:
41655 return NULL;
41656 }
41657
41658
41659 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41660 PyObject *resultobj = 0;
41661 wxMenu *arg1 = (wxMenu *) 0 ;
41662 void *argp1 = 0 ;
41663 int res1 = 0 ;
41664 PyObject *swig_obj[1] ;
41665
41666 if (!args) SWIG_fail;
41667 swig_obj[0] = args;
41668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41669 if (!SWIG_IsOK(res1)) {
41670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41671 }
41672 arg1 = reinterpret_cast< wxMenu * >(argp1);
41673 {
41674 PyThreadState* __tstate = wxPyBeginAllowThreads();
41675 (arg1)->Detach();
41676 wxPyEndAllowThreads(__tstate);
41677 if (PyErr_Occurred()) SWIG_fail;
41678 }
41679 resultobj = SWIG_Py_Void();
41680 return resultobj;
41681 fail:
41682 return NULL;
41683 }
41684
41685
41686 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41687 PyObject *resultobj = 0;
41688 wxMenu *arg1 = (wxMenu *) 0 ;
41689 bool result;
41690 void *argp1 = 0 ;
41691 int res1 = 0 ;
41692 PyObject *swig_obj[1] ;
41693
41694 if (!args) SWIG_fail;
41695 swig_obj[0] = args;
41696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41697 if (!SWIG_IsOK(res1)) {
41698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41699 }
41700 arg1 = reinterpret_cast< wxMenu * >(argp1);
41701 {
41702 PyThreadState* __tstate = wxPyBeginAllowThreads();
41703 result = (bool)((wxMenu const *)arg1)->IsAttached();
41704 wxPyEndAllowThreads(__tstate);
41705 if (PyErr_Occurred()) SWIG_fail;
41706 }
41707 {
41708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41709 }
41710 return resultobj;
41711 fail:
41712 return NULL;
41713 }
41714
41715
41716 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41717 PyObject *resultobj = 0;
41718 wxMenu *arg1 = (wxMenu *) 0 ;
41719 wxMenu *arg2 = (wxMenu *) 0 ;
41720 void *argp1 = 0 ;
41721 int res1 = 0 ;
41722 void *argp2 = 0 ;
41723 int res2 = 0 ;
41724 PyObject * obj0 = 0 ;
41725 PyObject * obj1 = 0 ;
41726 char * kwnames[] = {
41727 (char *) "self",(char *) "parent", NULL
41728 };
41729
41730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41732 if (!SWIG_IsOK(res1)) {
41733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41734 }
41735 arg1 = reinterpret_cast< wxMenu * >(argp1);
41736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41737 if (!SWIG_IsOK(res2)) {
41738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41739 }
41740 arg2 = reinterpret_cast< wxMenu * >(argp2);
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 (arg1)->SetParent(arg2);
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 resultobj = SWIG_Py_Void();
41748 return resultobj;
41749 fail:
41750 return NULL;
41751 }
41752
41753
41754 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41755 PyObject *resultobj = 0;
41756 wxMenu *arg1 = (wxMenu *) 0 ;
41757 wxMenu *result = 0 ;
41758 void *argp1 = 0 ;
41759 int res1 = 0 ;
41760 PyObject *swig_obj[1] ;
41761
41762 if (!args) SWIG_fail;
41763 swig_obj[0] = args;
41764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41765 if (!SWIG_IsOK(res1)) {
41766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41767 }
41768 arg1 = reinterpret_cast< wxMenu * >(argp1);
41769 {
41770 PyThreadState* __tstate = wxPyBeginAllowThreads();
41771 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41772 wxPyEndAllowThreads(__tstate);
41773 if (PyErr_Occurred()) SWIG_fail;
41774 }
41775 {
41776 resultobj = wxPyMake_wxObject(result, 0);
41777 }
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41785 PyObject *obj;
41786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41787 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41788 return SWIG_Py_Void();
41789 }
41790
41791 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41792 return SWIG_Python_InitShadowInstance(args);
41793 }
41794
41795 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41796 PyObject *resultobj = 0;
41797 long arg1 = (long) 0 ;
41798 wxMenuBar *result = 0 ;
41799 long val1 ;
41800 int ecode1 = 0 ;
41801 PyObject * obj0 = 0 ;
41802 char * kwnames[] = {
41803 (char *) "style", NULL
41804 };
41805
41806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41807 if (obj0) {
41808 ecode1 = SWIG_AsVal_long(obj0, &val1);
41809 if (!SWIG_IsOK(ecode1)) {
41810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41811 }
41812 arg1 = static_cast< long >(val1);
41813 }
41814 {
41815 if (!wxPyCheckForApp()) SWIG_fail;
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (wxMenuBar *)new wxMenuBar(arg1);
41818 wxPyEndAllowThreads(__tstate);
41819 if (PyErr_Occurred()) SWIG_fail;
41820 }
41821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41822 return resultobj;
41823 fail:
41824 return NULL;
41825 }
41826
41827
41828 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41829 PyObject *resultobj = 0;
41830 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41831 wxMenu *arg2 = (wxMenu *) 0 ;
41832 wxString *arg3 = 0 ;
41833 bool result;
41834 void *argp1 = 0 ;
41835 int res1 = 0 ;
41836 void *argp2 = 0 ;
41837 int res2 = 0 ;
41838 bool temp3 = false ;
41839 PyObject * obj0 = 0 ;
41840 PyObject * obj1 = 0 ;
41841 PyObject * obj2 = 0 ;
41842 char * kwnames[] = {
41843 (char *) "self",(char *) "menu",(char *) "title", NULL
41844 };
41845
41846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41848 if (!SWIG_IsOK(res1)) {
41849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41850 }
41851 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41853 if (!SWIG_IsOK(res2)) {
41854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41855 }
41856 arg2 = reinterpret_cast< wxMenu * >(argp2);
41857 {
41858 arg3 = wxString_in_helper(obj2);
41859 if (arg3 == NULL) SWIG_fail;
41860 temp3 = true;
41861 }
41862 {
41863 PyThreadState* __tstate = wxPyBeginAllowThreads();
41864 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41865 wxPyEndAllowThreads(__tstate);
41866 if (PyErr_Occurred()) SWIG_fail;
41867 }
41868 {
41869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41870 }
41871 {
41872 if (temp3)
41873 delete arg3;
41874 }
41875 return resultobj;
41876 fail:
41877 {
41878 if (temp3)
41879 delete arg3;
41880 }
41881 return NULL;
41882 }
41883
41884
41885 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41886 PyObject *resultobj = 0;
41887 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41888 size_t arg2 ;
41889 wxMenu *arg3 = (wxMenu *) 0 ;
41890 wxString *arg4 = 0 ;
41891 bool result;
41892 void *argp1 = 0 ;
41893 int res1 = 0 ;
41894 size_t val2 ;
41895 int ecode2 = 0 ;
41896 void *argp3 = 0 ;
41897 int res3 = 0 ;
41898 bool temp4 = false ;
41899 PyObject * obj0 = 0 ;
41900 PyObject * obj1 = 0 ;
41901 PyObject * obj2 = 0 ;
41902 PyObject * obj3 = 0 ;
41903 char * kwnames[] = {
41904 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41905 };
41906
41907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41909 if (!SWIG_IsOK(res1)) {
41910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41911 }
41912 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41913 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41914 if (!SWIG_IsOK(ecode2)) {
41915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41916 }
41917 arg2 = static_cast< size_t >(val2);
41918 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41919 if (!SWIG_IsOK(res3)) {
41920 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41921 }
41922 arg3 = reinterpret_cast< wxMenu * >(argp3);
41923 {
41924 arg4 = wxString_in_helper(obj3);
41925 if (arg4 == NULL) SWIG_fail;
41926 temp4 = true;
41927 }
41928 {
41929 PyThreadState* __tstate = wxPyBeginAllowThreads();
41930 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41931 wxPyEndAllowThreads(__tstate);
41932 if (PyErr_Occurred()) SWIG_fail;
41933 }
41934 {
41935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41936 }
41937 {
41938 if (temp4)
41939 delete arg4;
41940 }
41941 return resultobj;
41942 fail:
41943 {
41944 if (temp4)
41945 delete arg4;
41946 }
41947 return NULL;
41948 }
41949
41950
41951 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41952 PyObject *resultobj = 0;
41953 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41954 size_t result;
41955 void *argp1 = 0 ;
41956 int res1 = 0 ;
41957 PyObject *swig_obj[1] ;
41958
41959 if (!args) SWIG_fail;
41960 swig_obj[0] = args;
41961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41962 if (!SWIG_IsOK(res1)) {
41963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41964 }
41965 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41969 wxPyEndAllowThreads(__tstate);
41970 if (PyErr_Occurred()) SWIG_fail;
41971 }
41972 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41973 return resultobj;
41974 fail:
41975 return NULL;
41976 }
41977
41978
41979 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41980 PyObject *resultobj = 0;
41981 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41982 size_t arg2 ;
41983 wxMenu *result = 0 ;
41984 void *argp1 = 0 ;
41985 int res1 = 0 ;
41986 size_t val2 ;
41987 int ecode2 = 0 ;
41988 PyObject * obj0 = 0 ;
41989 PyObject * obj1 = 0 ;
41990 char * kwnames[] = {
41991 (char *) "self",(char *) "pos", NULL
41992 };
41993
41994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41996 if (!SWIG_IsOK(res1)) {
41997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41998 }
41999 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42000 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42001 if (!SWIG_IsOK(ecode2)) {
42002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42003 }
42004 arg2 = static_cast< size_t >(val2);
42005 {
42006 PyThreadState* __tstate = wxPyBeginAllowThreads();
42007 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42008 wxPyEndAllowThreads(__tstate);
42009 if (PyErr_Occurred()) SWIG_fail;
42010 }
42011 {
42012 resultobj = wxPyMake_wxObject(result, 0);
42013 }
42014 return resultobj;
42015 fail:
42016 return NULL;
42017 }
42018
42019
42020 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42021 PyObject *resultobj = 0;
42022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42023 size_t arg2 ;
42024 wxMenu *arg3 = (wxMenu *) 0 ;
42025 wxString *arg4 = 0 ;
42026 wxMenu *result = 0 ;
42027 void *argp1 = 0 ;
42028 int res1 = 0 ;
42029 size_t val2 ;
42030 int ecode2 = 0 ;
42031 void *argp3 = 0 ;
42032 int res3 = 0 ;
42033 bool temp4 = false ;
42034 PyObject * obj0 = 0 ;
42035 PyObject * obj1 = 0 ;
42036 PyObject * obj2 = 0 ;
42037 PyObject * obj3 = 0 ;
42038 char * kwnames[] = {
42039 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42040 };
42041
42042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42044 if (!SWIG_IsOK(res1)) {
42045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42046 }
42047 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42048 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42049 if (!SWIG_IsOK(ecode2)) {
42050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42051 }
42052 arg2 = static_cast< size_t >(val2);
42053 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42054 if (!SWIG_IsOK(res3)) {
42055 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42056 }
42057 arg3 = reinterpret_cast< wxMenu * >(argp3);
42058 {
42059 arg4 = wxString_in_helper(obj3);
42060 if (arg4 == NULL) SWIG_fail;
42061 temp4 = true;
42062 }
42063 {
42064 PyThreadState* __tstate = wxPyBeginAllowThreads();
42065 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42066 wxPyEndAllowThreads(__tstate);
42067 if (PyErr_Occurred()) SWIG_fail;
42068 }
42069 {
42070 resultobj = wxPyMake_wxObject(result, 0);
42071 }
42072 {
42073 if (temp4)
42074 delete arg4;
42075 }
42076 return resultobj;
42077 fail:
42078 {
42079 if (temp4)
42080 delete arg4;
42081 }
42082 return NULL;
42083 }
42084
42085
42086 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42087 PyObject *resultobj = 0;
42088 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42089 size_t arg2 ;
42090 wxMenu *result = 0 ;
42091 void *argp1 = 0 ;
42092 int res1 = 0 ;
42093 size_t val2 ;
42094 int ecode2 = 0 ;
42095 PyObject * obj0 = 0 ;
42096 PyObject * obj1 = 0 ;
42097 char * kwnames[] = {
42098 (char *) "self",(char *) "pos", NULL
42099 };
42100
42101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42103 if (!SWIG_IsOK(res1)) {
42104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42105 }
42106 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42107 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42108 if (!SWIG_IsOK(ecode2)) {
42109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42110 }
42111 arg2 = static_cast< size_t >(val2);
42112 {
42113 PyThreadState* __tstate = wxPyBeginAllowThreads();
42114 result = (wxMenu *)(arg1)->Remove(arg2);
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 {
42119 resultobj = wxPyMake_wxObject(result, 0);
42120 }
42121 return resultobj;
42122 fail:
42123 return NULL;
42124 }
42125
42126
42127 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42128 PyObject *resultobj = 0;
42129 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42130 size_t arg2 ;
42131 bool arg3 ;
42132 void *argp1 = 0 ;
42133 int res1 = 0 ;
42134 size_t val2 ;
42135 int ecode2 = 0 ;
42136 bool val3 ;
42137 int ecode3 = 0 ;
42138 PyObject * obj0 = 0 ;
42139 PyObject * obj1 = 0 ;
42140 PyObject * obj2 = 0 ;
42141 char * kwnames[] = {
42142 (char *) "self",(char *) "pos",(char *) "enable", NULL
42143 };
42144
42145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42147 if (!SWIG_IsOK(res1)) {
42148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42149 }
42150 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42151 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42152 if (!SWIG_IsOK(ecode2)) {
42153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42154 }
42155 arg2 = static_cast< size_t >(val2);
42156 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42157 if (!SWIG_IsOK(ecode3)) {
42158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42159 }
42160 arg3 = static_cast< bool >(val3);
42161 {
42162 PyThreadState* __tstate = wxPyBeginAllowThreads();
42163 (arg1)->EnableTop(arg2,arg3);
42164 wxPyEndAllowThreads(__tstate);
42165 if (PyErr_Occurred()) SWIG_fail;
42166 }
42167 resultobj = SWIG_Py_Void();
42168 return resultobj;
42169 fail:
42170 return NULL;
42171 }
42172
42173
42174 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42175 PyObject *resultobj = 0;
42176 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42177 size_t arg2 ;
42178 bool result;
42179 void *argp1 = 0 ;
42180 int res1 = 0 ;
42181 size_t val2 ;
42182 int ecode2 = 0 ;
42183 PyObject * obj0 = 0 ;
42184 PyObject * obj1 = 0 ;
42185 char * kwnames[] = {
42186 (char *) "self",(char *) "pos", NULL
42187 };
42188
42189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42191 if (!SWIG_IsOK(res1)) {
42192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42193 }
42194 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42195 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42196 if (!SWIG_IsOK(ecode2)) {
42197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42198 }
42199 arg2 = static_cast< size_t >(val2);
42200 {
42201 PyThreadState* __tstate = wxPyBeginAllowThreads();
42202 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42203 wxPyEndAllowThreads(__tstate);
42204 if (PyErr_Occurred()) SWIG_fail;
42205 }
42206 {
42207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42208 }
42209 return resultobj;
42210 fail:
42211 return NULL;
42212 }
42213
42214
42215 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42216 PyObject *resultobj = 0;
42217 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42218 size_t arg2 ;
42219 wxString *arg3 = 0 ;
42220 void *argp1 = 0 ;
42221 int res1 = 0 ;
42222 size_t val2 ;
42223 int ecode2 = 0 ;
42224 bool temp3 = false ;
42225 PyObject * obj0 = 0 ;
42226 PyObject * obj1 = 0 ;
42227 PyObject * obj2 = 0 ;
42228 char * kwnames[] = {
42229 (char *) "self",(char *) "pos",(char *) "label", NULL
42230 };
42231
42232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42234 if (!SWIG_IsOK(res1)) {
42235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42236 }
42237 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42238 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42239 if (!SWIG_IsOK(ecode2)) {
42240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42241 }
42242 arg2 = static_cast< size_t >(val2);
42243 {
42244 arg3 = wxString_in_helper(obj2);
42245 if (arg3 == NULL) SWIG_fail;
42246 temp3 = true;
42247 }
42248 {
42249 PyThreadState* __tstate = wxPyBeginAllowThreads();
42250 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42251 wxPyEndAllowThreads(__tstate);
42252 if (PyErr_Occurred()) SWIG_fail;
42253 }
42254 resultobj = SWIG_Py_Void();
42255 {
42256 if (temp3)
42257 delete arg3;
42258 }
42259 return resultobj;
42260 fail:
42261 {
42262 if (temp3)
42263 delete arg3;
42264 }
42265 return NULL;
42266 }
42267
42268
42269 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42270 PyObject *resultobj = 0;
42271 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42272 size_t arg2 ;
42273 wxString result;
42274 void *argp1 = 0 ;
42275 int res1 = 0 ;
42276 size_t val2 ;
42277 int ecode2 = 0 ;
42278 PyObject * obj0 = 0 ;
42279 PyObject * obj1 = 0 ;
42280 char * kwnames[] = {
42281 (char *) "self",(char *) "pos", NULL
42282 };
42283
42284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42286 if (!SWIG_IsOK(res1)) {
42287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42288 }
42289 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42290 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42291 if (!SWIG_IsOK(ecode2)) {
42292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42293 }
42294 arg2 = static_cast< size_t >(val2);
42295 {
42296 PyThreadState* __tstate = wxPyBeginAllowThreads();
42297 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42298 wxPyEndAllowThreads(__tstate);
42299 if (PyErr_Occurred()) SWIG_fail;
42300 }
42301 {
42302 #if wxUSE_UNICODE
42303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42304 #else
42305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42306 #endif
42307 }
42308 return resultobj;
42309 fail:
42310 return NULL;
42311 }
42312
42313
42314 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42315 PyObject *resultobj = 0;
42316 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42317 wxString *arg2 = 0 ;
42318 wxString *arg3 = 0 ;
42319 int result;
42320 void *argp1 = 0 ;
42321 int res1 = 0 ;
42322 bool temp2 = false ;
42323 bool temp3 = false ;
42324 PyObject * obj0 = 0 ;
42325 PyObject * obj1 = 0 ;
42326 PyObject * obj2 = 0 ;
42327 char * kwnames[] = {
42328 (char *) "self",(char *) "menu",(char *) "item", NULL
42329 };
42330
42331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42333 if (!SWIG_IsOK(res1)) {
42334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42335 }
42336 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42337 {
42338 arg2 = wxString_in_helper(obj1);
42339 if (arg2 == NULL) SWIG_fail;
42340 temp2 = true;
42341 }
42342 {
42343 arg3 = wxString_in_helper(obj2);
42344 if (arg3 == NULL) SWIG_fail;
42345 temp3 = true;
42346 }
42347 {
42348 PyThreadState* __tstate = wxPyBeginAllowThreads();
42349 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42350 wxPyEndAllowThreads(__tstate);
42351 if (PyErr_Occurred()) SWIG_fail;
42352 }
42353 resultobj = SWIG_From_int(static_cast< int >(result));
42354 {
42355 if (temp2)
42356 delete arg2;
42357 }
42358 {
42359 if (temp3)
42360 delete arg3;
42361 }
42362 return resultobj;
42363 fail:
42364 {
42365 if (temp2)
42366 delete arg2;
42367 }
42368 {
42369 if (temp3)
42370 delete arg3;
42371 }
42372 return NULL;
42373 }
42374
42375
42376 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42377 PyObject *resultobj = 0;
42378 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42379 int arg2 ;
42380 wxMenuItem *result = 0 ;
42381 void *argp1 = 0 ;
42382 int res1 = 0 ;
42383 int val2 ;
42384 int ecode2 = 0 ;
42385 PyObject * obj0 = 0 ;
42386 PyObject * obj1 = 0 ;
42387 char * kwnames[] = {
42388 (char *) "self",(char *) "id", NULL
42389 };
42390
42391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42393 if (!SWIG_IsOK(res1)) {
42394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42395 }
42396 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42397 ecode2 = SWIG_AsVal_int(obj1, &val2);
42398 if (!SWIG_IsOK(ecode2)) {
42399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42400 }
42401 arg2 = static_cast< int >(val2);
42402 {
42403 PyThreadState* __tstate = wxPyBeginAllowThreads();
42404 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42405 wxPyEndAllowThreads(__tstate);
42406 if (PyErr_Occurred()) SWIG_fail;
42407 }
42408 {
42409 resultobj = wxPyMake_wxObject(result, (bool)0);
42410 }
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42418 PyObject *resultobj = 0;
42419 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42420 wxString *arg2 = 0 ;
42421 int result;
42422 void *argp1 = 0 ;
42423 int res1 = 0 ;
42424 bool temp2 = false ;
42425 PyObject * obj0 = 0 ;
42426 PyObject * obj1 = 0 ;
42427 char * kwnames[] = {
42428 (char *) "self",(char *) "title", NULL
42429 };
42430
42431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42433 if (!SWIG_IsOK(res1)) {
42434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42435 }
42436 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42437 {
42438 arg2 = wxString_in_helper(obj1);
42439 if (arg2 == NULL) SWIG_fail;
42440 temp2 = true;
42441 }
42442 {
42443 PyThreadState* __tstate = wxPyBeginAllowThreads();
42444 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42445 wxPyEndAllowThreads(__tstate);
42446 if (PyErr_Occurred()) SWIG_fail;
42447 }
42448 resultobj = SWIG_From_int(static_cast< int >(result));
42449 {
42450 if (temp2)
42451 delete arg2;
42452 }
42453 return resultobj;
42454 fail:
42455 {
42456 if (temp2)
42457 delete arg2;
42458 }
42459 return NULL;
42460 }
42461
42462
42463 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42464 PyObject *resultobj = 0;
42465 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42466 int arg2 ;
42467 bool arg3 ;
42468 void *argp1 = 0 ;
42469 int res1 = 0 ;
42470 int val2 ;
42471 int ecode2 = 0 ;
42472 bool val3 ;
42473 int ecode3 = 0 ;
42474 PyObject * obj0 = 0 ;
42475 PyObject * obj1 = 0 ;
42476 PyObject * obj2 = 0 ;
42477 char * kwnames[] = {
42478 (char *) "self",(char *) "id",(char *) "enable", NULL
42479 };
42480
42481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42483 if (!SWIG_IsOK(res1)) {
42484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42485 }
42486 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42487 ecode2 = SWIG_AsVal_int(obj1, &val2);
42488 if (!SWIG_IsOK(ecode2)) {
42489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42490 }
42491 arg2 = static_cast< int >(val2);
42492 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42493 if (!SWIG_IsOK(ecode3)) {
42494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42495 }
42496 arg3 = static_cast< bool >(val3);
42497 {
42498 PyThreadState* __tstate = wxPyBeginAllowThreads();
42499 (arg1)->Enable(arg2,arg3);
42500 wxPyEndAllowThreads(__tstate);
42501 if (PyErr_Occurred()) SWIG_fail;
42502 }
42503 resultobj = SWIG_Py_Void();
42504 return resultobj;
42505 fail:
42506 return NULL;
42507 }
42508
42509
42510 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42511 PyObject *resultobj = 0;
42512 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42513 int arg2 ;
42514 bool arg3 ;
42515 void *argp1 = 0 ;
42516 int res1 = 0 ;
42517 int val2 ;
42518 int ecode2 = 0 ;
42519 bool val3 ;
42520 int ecode3 = 0 ;
42521 PyObject * obj0 = 0 ;
42522 PyObject * obj1 = 0 ;
42523 PyObject * obj2 = 0 ;
42524 char * kwnames[] = {
42525 (char *) "self",(char *) "id",(char *) "check", NULL
42526 };
42527
42528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42530 if (!SWIG_IsOK(res1)) {
42531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42532 }
42533 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42534 ecode2 = SWIG_AsVal_int(obj1, &val2);
42535 if (!SWIG_IsOK(ecode2)) {
42536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42537 }
42538 arg2 = static_cast< int >(val2);
42539 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42540 if (!SWIG_IsOK(ecode3)) {
42541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42542 }
42543 arg3 = static_cast< bool >(val3);
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 (arg1)->Check(arg2,arg3);
42547 wxPyEndAllowThreads(__tstate);
42548 if (PyErr_Occurred()) SWIG_fail;
42549 }
42550 resultobj = SWIG_Py_Void();
42551 return resultobj;
42552 fail:
42553 return NULL;
42554 }
42555
42556
42557 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42558 PyObject *resultobj = 0;
42559 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42560 int arg2 ;
42561 bool result;
42562 void *argp1 = 0 ;
42563 int res1 = 0 ;
42564 int val2 ;
42565 int ecode2 = 0 ;
42566 PyObject * obj0 = 0 ;
42567 PyObject * obj1 = 0 ;
42568 char * kwnames[] = {
42569 (char *) "self",(char *) "id", NULL
42570 };
42571
42572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42574 if (!SWIG_IsOK(res1)) {
42575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42576 }
42577 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42578 ecode2 = SWIG_AsVal_int(obj1, &val2);
42579 if (!SWIG_IsOK(ecode2)) {
42580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42581 }
42582 arg2 = static_cast< int >(val2);
42583 {
42584 PyThreadState* __tstate = wxPyBeginAllowThreads();
42585 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42586 wxPyEndAllowThreads(__tstate);
42587 if (PyErr_Occurred()) SWIG_fail;
42588 }
42589 {
42590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42591 }
42592 return resultobj;
42593 fail:
42594 return NULL;
42595 }
42596
42597
42598 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42599 PyObject *resultobj = 0;
42600 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42601 int arg2 ;
42602 bool result;
42603 void *argp1 = 0 ;
42604 int res1 = 0 ;
42605 int val2 ;
42606 int ecode2 = 0 ;
42607 PyObject * obj0 = 0 ;
42608 PyObject * obj1 = 0 ;
42609 char * kwnames[] = {
42610 (char *) "self",(char *) "id", NULL
42611 };
42612
42613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42615 if (!SWIG_IsOK(res1)) {
42616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42617 }
42618 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42619 ecode2 = SWIG_AsVal_int(obj1, &val2);
42620 if (!SWIG_IsOK(ecode2)) {
42621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42622 }
42623 arg2 = static_cast< int >(val2);
42624 {
42625 PyThreadState* __tstate = wxPyBeginAllowThreads();
42626 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42627 wxPyEndAllowThreads(__tstate);
42628 if (PyErr_Occurred()) SWIG_fail;
42629 }
42630 {
42631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42632 }
42633 return resultobj;
42634 fail:
42635 return NULL;
42636 }
42637
42638
42639 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42640 PyObject *resultobj = 0;
42641 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42642 int arg2 ;
42643 wxString *arg3 = 0 ;
42644 void *argp1 = 0 ;
42645 int res1 = 0 ;
42646 int val2 ;
42647 int ecode2 = 0 ;
42648 bool temp3 = false ;
42649 PyObject * obj0 = 0 ;
42650 PyObject * obj1 = 0 ;
42651 PyObject * obj2 = 0 ;
42652 char * kwnames[] = {
42653 (char *) "self",(char *) "id",(char *) "label", NULL
42654 };
42655
42656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42658 if (!SWIG_IsOK(res1)) {
42659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42660 }
42661 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42662 ecode2 = SWIG_AsVal_int(obj1, &val2);
42663 if (!SWIG_IsOK(ecode2)) {
42664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42665 }
42666 arg2 = static_cast< int >(val2);
42667 {
42668 arg3 = wxString_in_helper(obj2);
42669 if (arg3 == NULL) SWIG_fail;
42670 temp3 = true;
42671 }
42672 {
42673 PyThreadState* __tstate = wxPyBeginAllowThreads();
42674 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42675 wxPyEndAllowThreads(__tstate);
42676 if (PyErr_Occurred()) SWIG_fail;
42677 }
42678 resultobj = SWIG_Py_Void();
42679 {
42680 if (temp3)
42681 delete arg3;
42682 }
42683 return resultobj;
42684 fail:
42685 {
42686 if (temp3)
42687 delete arg3;
42688 }
42689 return NULL;
42690 }
42691
42692
42693 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42694 PyObject *resultobj = 0;
42695 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42696 int arg2 ;
42697 wxString result;
42698 void *argp1 = 0 ;
42699 int res1 = 0 ;
42700 int val2 ;
42701 int ecode2 = 0 ;
42702 PyObject * obj0 = 0 ;
42703 PyObject * obj1 = 0 ;
42704 char * kwnames[] = {
42705 (char *) "self",(char *) "id", NULL
42706 };
42707
42708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42710 if (!SWIG_IsOK(res1)) {
42711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42712 }
42713 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42714 ecode2 = SWIG_AsVal_int(obj1, &val2);
42715 if (!SWIG_IsOK(ecode2)) {
42716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42717 }
42718 arg2 = static_cast< int >(val2);
42719 {
42720 PyThreadState* __tstate = wxPyBeginAllowThreads();
42721 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42722 wxPyEndAllowThreads(__tstate);
42723 if (PyErr_Occurred()) SWIG_fail;
42724 }
42725 {
42726 #if wxUSE_UNICODE
42727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42728 #else
42729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42730 #endif
42731 }
42732 return resultobj;
42733 fail:
42734 return NULL;
42735 }
42736
42737
42738 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42739 PyObject *resultobj = 0;
42740 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42741 int arg2 ;
42742 wxString *arg3 = 0 ;
42743 void *argp1 = 0 ;
42744 int res1 = 0 ;
42745 int val2 ;
42746 int ecode2 = 0 ;
42747 bool temp3 = false ;
42748 PyObject * obj0 = 0 ;
42749 PyObject * obj1 = 0 ;
42750 PyObject * obj2 = 0 ;
42751 char * kwnames[] = {
42752 (char *) "self",(char *) "id",(char *) "helpString", NULL
42753 };
42754
42755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42757 if (!SWIG_IsOK(res1)) {
42758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42759 }
42760 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42761 ecode2 = SWIG_AsVal_int(obj1, &val2);
42762 if (!SWIG_IsOK(ecode2)) {
42763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42764 }
42765 arg2 = static_cast< int >(val2);
42766 {
42767 arg3 = wxString_in_helper(obj2);
42768 if (arg3 == NULL) SWIG_fail;
42769 temp3 = true;
42770 }
42771 {
42772 PyThreadState* __tstate = wxPyBeginAllowThreads();
42773 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42774 wxPyEndAllowThreads(__tstate);
42775 if (PyErr_Occurred()) SWIG_fail;
42776 }
42777 resultobj = SWIG_Py_Void();
42778 {
42779 if (temp3)
42780 delete arg3;
42781 }
42782 return resultobj;
42783 fail:
42784 {
42785 if (temp3)
42786 delete arg3;
42787 }
42788 return NULL;
42789 }
42790
42791
42792 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42793 PyObject *resultobj = 0;
42794 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42795 int arg2 ;
42796 wxString result;
42797 void *argp1 = 0 ;
42798 int res1 = 0 ;
42799 int val2 ;
42800 int ecode2 = 0 ;
42801 PyObject * obj0 = 0 ;
42802 PyObject * obj1 = 0 ;
42803 char * kwnames[] = {
42804 (char *) "self",(char *) "id", NULL
42805 };
42806
42807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42809 if (!SWIG_IsOK(res1)) {
42810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42811 }
42812 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42813 ecode2 = SWIG_AsVal_int(obj1, &val2);
42814 if (!SWIG_IsOK(ecode2)) {
42815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42816 }
42817 arg2 = static_cast< int >(val2);
42818 {
42819 PyThreadState* __tstate = wxPyBeginAllowThreads();
42820 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42821 wxPyEndAllowThreads(__tstate);
42822 if (PyErr_Occurred()) SWIG_fail;
42823 }
42824 {
42825 #if wxUSE_UNICODE
42826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42827 #else
42828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42829 #endif
42830 }
42831 return resultobj;
42832 fail:
42833 return NULL;
42834 }
42835
42836
42837 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42838 PyObject *resultobj = 0;
42839 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42840 wxFrame *result = 0 ;
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_wxMenuBar, 0 | 0 );
42848 if (!SWIG_IsOK(res1)) {
42849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42850 }
42851 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42855 wxPyEndAllowThreads(__tstate);
42856 if (PyErr_Occurred()) SWIG_fail;
42857 }
42858 {
42859 resultobj = wxPyMake_wxObject(result, (bool)0);
42860 }
42861 return resultobj;
42862 fail:
42863 return NULL;
42864 }
42865
42866
42867 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42868 PyObject *resultobj = 0;
42869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42870 bool result;
42871 void *argp1 = 0 ;
42872 int res1 = 0 ;
42873 PyObject *swig_obj[1] ;
42874
42875 if (!args) SWIG_fail;
42876 swig_obj[0] = args;
42877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42878 if (!SWIG_IsOK(res1)) {
42879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42880 }
42881 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42882 {
42883 PyThreadState* __tstate = wxPyBeginAllowThreads();
42884 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42885 wxPyEndAllowThreads(__tstate);
42886 if (PyErr_Occurred()) SWIG_fail;
42887 }
42888 {
42889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42890 }
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42898 PyObject *resultobj = 0;
42899 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42900 wxFrame *arg2 = (wxFrame *) 0 ;
42901 void *argp1 = 0 ;
42902 int res1 = 0 ;
42903 void *argp2 = 0 ;
42904 int res2 = 0 ;
42905 PyObject * obj0 = 0 ;
42906 PyObject * obj1 = 0 ;
42907 char * kwnames[] = {
42908 (char *) "self",(char *) "frame", NULL
42909 };
42910
42911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42913 if (!SWIG_IsOK(res1)) {
42914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42915 }
42916 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42917 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42918 if (!SWIG_IsOK(res2)) {
42919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42920 }
42921 arg2 = reinterpret_cast< wxFrame * >(argp2);
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 (arg1)->Attach(arg2);
42925 wxPyEndAllowThreads(__tstate);
42926 if (PyErr_Occurred()) SWIG_fail;
42927 }
42928 resultobj = SWIG_Py_Void();
42929 return resultobj;
42930 fail:
42931 return NULL;
42932 }
42933
42934
42935 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42936 PyObject *resultobj = 0;
42937 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42938 void *argp1 = 0 ;
42939 int res1 = 0 ;
42940 PyObject *swig_obj[1] ;
42941
42942 if (!args) SWIG_fail;
42943 swig_obj[0] = args;
42944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42945 if (!SWIG_IsOK(res1)) {
42946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42947 }
42948 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42949 {
42950 PyThreadState* __tstate = wxPyBeginAllowThreads();
42951 (arg1)->Detach();
42952 wxPyEndAllowThreads(__tstate);
42953 if (PyErr_Occurred()) SWIG_fail;
42954 }
42955 resultobj = SWIG_Py_Void();
42956 return resultobj;
42957 fail:
42958 return NULL;
42959 }
42960
42961
42962 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42963 PyObject *resultobj = 0;
42964 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42965 void *argp1 = 0 ;
42966 int res1 = 0 ;
42967 PyObject *swig_obj[1] ;
42968
42969 if (!args) SWIG_fail;
42970 swig_obj[0] = args;
42971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42972 if (!SWIG_IsOK(res1)) {
42973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42974 }
42975 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42976 {
42977 PyThreadState* __tstate = wxPyBeginAllowThreads();
42978 (arg1)->UpdateMenus();
42979 wxPyEndAllowThreads(__tstate);
42980 if (PyErr_Occurred()) SWIG_fail;
42981 }
42982 resultobj = SWIG_Py_Void();
42983 return resultobj;
42984 fail:
42985 return NULL;
42986 }
42987
42988
42989 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42990 PyObject *resultobj = 0;
42991 bool arg1 ;
42992 bool val1 ;
42993 int ecode1 = 0 ;
42994 PyObject * obj0 = 0 ;
42995 char * kwnames[] = {
42996 (char *) "enable", NULL
42997 };
42998
42999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43000 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43001 if (!SWIG_IsOK(ecode1)) {
43002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43003 }
43004 arg1 = static_cast< bool >(val1);
43005 {
43006 PyThreadState* __tstate = wxPyBeginAllowThreads();
43007 wxMenuBar_SetAutoWindowMenu(arg1);
43008 wxPyEndAllowThreads(__tstate);
43009 if (PyErr_Occurred()) SWIG_fail;
43010 }
43011 resultobj = SWIG_Py_Void();
43012 return resultobj;
43013 fail:
43014 return NULL;
43015 }
43016
43017
43018 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43019 PyObject *resultobj = 0;
43020 bool result;
43021
43022 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43023 {
43024 PyThreadState* __tstate = wxPyBeginAllowThreads();
43025 result = (bool)wxMenuBar_GetAutoWindowMenu();
43026 wxPyEndAllowThreads(__tstate);
43027 if (PyErr_Occurred()) SWIG_fail;
43028 }
43029 {
43030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43031 }
43032 return resultobj;
43033 fail:
43034 return NULL;
43035 }
43036
43037
43038 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43039 PyObject *obj;
43040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43041 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43042 return SWIG_Py_Void();
43043 }
43044
43045 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43046 return SWIG_Python_InitShadowInstance(args);
43047 }
43048
43049 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43050 PyObject *resultobj = 0;
43051 wxMenu *arg1 = (wxMenu *) NULL ;
43052 int arg2 = (int) wxID_ANY ;
43053 wxString const &arg3_defvalue = wxPyEmptyString ;
43054 wxString *arg3 = (wxString *) &arg3_defvalue ;
43055 wxString const &arg4_defvalue = wxPyEmptyString ;
43056 wxString *arg4 = (wxString *) &arg4_defvalue ;
43057 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43058 wxMenu *arg6 = (wxMenu *) NULL ;
43059 wxMenuItem *result = 0 ;
43060 void *argp1 = 0 ;
43061 int res1 = 0 ;
43062 int val2 ;
43063 int ecode2 = 0 ;
43064 bool temp3 = false ;
43065 bool temp4 = false ;
43066 int val5 ;
43067 int ecode5 = 0 ;
43068 void *argp6 = 0 ;
43069 int res6 = 0 ;
43070 PyObject * obj0 = 0 ;
43071 PyObject * obj1 = 0 ;
43072 PyObject * obj2 = 0 ;
43073 PyObject * obj3 = 0 ;
43074 PyObject * obj4 = 0 ;
43075 PyObject * obj5 = 0 ;
43076 char * kwnames[] = {
43077 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43078 };
43079
43080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43081 if (obj0) {
43082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43083 if (!SWIG_IsOK(res1)) {
43084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43085 }
43086 arg1 = reinterpret_cast< wxMenu * >(argp1);
43087 }
43088 if (obj1) {
43089 ecode2 = SWIG_AsVal_int(obj1, &val2);
43090 if (!SWIG_IsOK(ecode2)) {
43091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43092 }
43093 arg2 = static_cast< int >(val2);
43094 }
43095 if (obj2) {
43096 {
43097 arg3 = wxString_in_helper(obj2);
43098 if (arg3 == NULL) SWIG_fail;
43099 temp3 = true;
43100 }
43101 }
43102 if (obj3) {
43103 {
43104 arg4 = wxString_in_helper(obj3);
43105 if (arg4 == NULL) SWIG_fail;
43106 temp4 = true;
43107 }
43108 }
43109 if (obj4) {
43110 ecode5 = SWIG_AsVal_int(obj4, &val5);
43111 if (!SWIG_IsOK(ecode5)) {
43112 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43113 }
43114 arg5 = static_cast< wxItemKind >(val5);
43115 }
43116 if (obj5) {
43117 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43118 if (!SWIG_IsOK(res6)) {
43119 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43120 }
43121 arg6 = reinterpret_cast< wxMenu * >(argp6);
43122 }
43123 {
43124 PyThreadState* __tstate = wxPyBeginAllowThreads();
43125 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43126 wxPyEndAllowThreads(__tstate);
43127 if (PyErr_Occurred()) SWIG_fail;
43128 }
43129 {
43130 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43131 }
43132 {
43133 if (temp3)
43134 delete arg3;
43135 }
43136 {
43137 if (temp4)
43138 delete arg4;
43139 }
43140 return resultobj;
43141 fail:
43142 {
43143 if (temp3)
43144 delete arg3;
43145 }
43146 {
43147 if (temp4)
43148 delete arg4;
43149 }
43150 return NULL;
43151 }
43152
43153
43154 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43155 PyObject *resultobj = 0;
43156 wxMenuItem *arg1 = (wxMenuItem *) 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, SWIG_POINTER_DISOWN | 0 );
43164 if (!SWIG_IsOK(res1)) {
43165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43166 }
43167 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43168 {
43169 PyThreadState* __tstate = wxPyBeginAllowThreads();
43170 delete arg1;
43171
43172 wxPyEndAllowThreads(__tstate);
43173 if (PyErr_Occurred()) SWIG_fail;
43174 }
43175 resultobj = SWIG_Py_Void();
43176 return resultobj;
43177 fail:
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43183 PyObject *resultobj = 0;
43184 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43185 wxMenu *result = 0 ;
43186 void *argp1 = 0 ;
43187 int res1 = 0 ;
43188 PyObject *swig_obj[1] ;
43189
43190 if (!args) SWIG_fail;
43191 swig_obj[0] = args;
43192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43193 if (!SWIG_IsOK(res1)) {
43194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43195 }
43196 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43197 {
43198 PyThreadState* __tstate = wxPyBeginAllowThreads();
43199 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43200 wxPyEndAllowThreads(__tstate);
43201 if (PyErr_Occurred()) SWIG_fail;
43202 }
43203 {
43204 resultobj = wxPyMake_wxObject(result, 0);
43205 }
43206 return resultobj;
43207 fail:
43208 return NULL;
43209 }
43210
43211
43212 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43213 PyObject *resultobj = 0;
43214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43215 wxMenu *arg2 = (wxMenu *) 0 ;
43216 void *argp1 = 0 ;
43217 int res1 = 0 ;
43218 void *argp2 = 0 ;
43219 int res2 = 0 ;
43220 PyObject * obj0 = 0 ;
43221 PyObject * obj1 = 0 ;
43222 char * kwnames[] = {
43223 (char *) "self",(char *) "menu", NULL
43224 };
43225
43226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43228 if (!SWIG_IsOK(res1)) {
43229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43230 }
43231 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43233 if (!SWIG_IsOK(res2)) {
43234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43235 }
43236 arg2 = reinterpret_cast< wxMenu * >(argp2);
43237 {
43238 PyThreadState* __tstate = wxPyBeginAllowThreads();
43239 (arg1)->SetMenu(arg2);
43240 wxPyEndAllowThreads(__tstate);
43241 if (PyErr_Occurred()) SWIG_fail;
43242 }
43243 resultobj = SWIG_Py_Void();
43244 return resultobj;
43245 fail:
43246 return NULL;
43247 }
43248
43249
43250 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43251 PyObject *resultobj = 0;
43252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43253 int arg2 ;
43254 void *argp1 = 0 ;
43255 int res1 = 0 ;
43256 int val2 ;
43257 int ecode2 = 0 ;
43258 PyObject * obj0 = 0 ;
43259 PyObject * obj1 = 0 ;
43260 char * kwnames[] = {
43261 (char *) "self",(char *) "id", NULL
43262 };
43263
43264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43266 if (!SWIG_IsOK(res1)) {
43267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43268 }
43269 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43270 ecode2 = SWIG_AsVal_int(obj1, &val2);
43271 if (!SWIG_IsOK(ecode2)) {
43272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43273 }
43274 arg2 = static_cast< int >(val2);
43275 {
43276 PyThreadState* __tstate = wxPyBeginAllowThreads();
43277 (arg1)->SetId(arg2);
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 resultobj = SWIG_Py_Void();
43282 return resultobj;
43283 fail:
43284 return NULL;
43285 }
43286
43287
43288 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43289 PyObject *resultobj = 0;
43290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43291 int result;
43292 void *argp1 = 0 ;
43293 int res1 = 0 ;
43294 PyObject *swig_obj[1] ;
43295
43296 if (!args) SWIG_fail;
43297 swig_obj[0] = args;
43298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43299 if (!SWIG_IsOK(res1)) {
43300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43301 }
43302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 result = (int)((wxMenuItem const *)arg1)->GetId();
43306 wxPyEndAllowThreads(__tstate);
43307 if (PyErr_Occurred()) SWIG_fail;
43308 }
43309 resultobj = SWIG_From_int(static_cast< int >(result));
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43317 PyObject *resultobj = 0;
43318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43319 bool result;
43320 void *argp1 = 0 ;
43321 int res1 = 0 ;
43322 PyObject *swig_obj[1] ;
43323
43324 if (!args) SWIG_fail;
43325 swig_obj[0] = args;
43326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43327 if (!SWIG_IsOK(res1)) {
43328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43329 }
43330 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43331 {
43332 PyThreadState* __tstate = wxPyBeginAllowThreads();
43333 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43334 wxPyEndAllowThreads(__tstate);
43335 if (PyErr_Occurred()) SWIG_fail;
43336 }
43337 {
43338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43339 }
43340 return resultobj;
43341 fail:
43342 return NULL;
43343 }
43344
43345
43346 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43347 PyObject *resultobj = 0;
43348 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43349 wxString *arg2 = 0 ;
43350 void *argp1 = 0 ;
43351 int res1 = 0 ;
43352 bool temp2 = false ;
43353 PyObject * obj0 = 0 ;
43354 PyObject * obj1 = 0 ;
43355 char * kwnames[] = {
43356 (char *) "self",(char *) "str", NULL
43357 };
43358
43359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43361 if (!SWIG_IsOK(res1)) {
43362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43363 }
43364 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43365 {
43366 arg2 = wxString_in_helper(obj1);
43367 if (arg2 == NULL) SWIG_fail;
43368 temp2 = true;
43369 }
43370 {
43371 PyThreadState* __tstate = wxPyBeginAllowThreads();
43372 (arg1)->SetText((wxString const &)*arg2);
43373 wxPyEndAllowThreads(__tstate);
43374 if (PyErr_Occurred()) SWIG_fail;
43375 }
43376 resultobj = SWIG_Py_Void();
43377 {
43378 if (temp2)
43379 delete arg2;
43380 }
43381 return resultobj;
43382 fail:
43383 {
43384 if (temp2)
43385 delete arg2;
43386 }
43387 return NULL;
43388 }
43389
43390
43391 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43392 PyObject *resultobj = 0;
43393 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43394 wxString result;
43395 void *argp1 = 0 ;
43396 int res1 = 0 ;
43397 PyObject *swig_obj[1] ;
43398
43399 if (!args) SWIG_fail;
43400 swig_obj[0] = args;
43401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43402 if (!SWIG_IsOK(res1)) {
43403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43404 }
43405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43406 {
43407 PyThreadState* __tstate = wxPyBeginAllowThreads();
43408 result = ((wxMenuItem const *)arg1)->GetLabel();
43409 wxPyEndAllowThreads(__tstate);
43410 if (PyErr_Occurred()) SWIG_fail;
43411 }
43412 {
43413 #if wxUSE_UNICODE
43414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43415 #else
43416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43417 #endif
43418 }
43419 return resultobj;
43420 fail:
43421 return NULL;
43422 }
43423
43424
43425 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43426 PyObject *resultobj = 0;
43427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43428 wxString *result = 0 ;
43429 void *argp1 = 0 ;
43430 int res1 = 0 ;
43431 PyObject *swig_obj[1] ;
43432
43433 if (!args) SWIG_fail;
43434 swig_obj[0] = args;
43435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43436 if (!SWIG_IsOK(res1)) {
43437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43438 }
43439 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43440 {
43441 PyThreadState* __tstate = wxPyBeginAllowThreads();
43442 {
43443 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43444 result = (wxString *) &_result_ref;
43445 }
43446 wxPyEndAllowThreads(__tstate);
43447 if (PyErr_Occurred()) SWIG_fail;
43448 }
43449 {
43450 #if wxUSE_UNICODE
43451 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43452 #else
43453 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43454 #endif
43455 }
43456 return resultobj;
43457 fail:
43458 return NULL;
43459 }
43460
43461
43462 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43463 PyObject *resultobj = 0;
43464 wxString *arg1 = 0 ;
43465 wxString result;
43466 bool temp1 = false ;
43467 PyObject * obj0 = 0 ;
43468 char * kwnames[] = {
43469 (char *) "text", NULL
43470 };
43471
43472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43473 {
43474 arg1 = wxString_in_helper(obj0);
43475 if (arg1 == NULL) SWIG_fail;
43476 temp1 = true;
43477 }
43478 {
43479 PyThreadState* __tstate = wxPyBeginAllowThreads();
43480 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43481 wxPyEndAllowThreads(__tstate);
43482 if (PyErr_Occurred()) SWIG_fail;
43483 }
43484 {
43485 #if wxUSE_UNICODE
43486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43487 #else
43488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43489 #endif
43490 }
43491 {
43492 if (temp1)
43493 delete arg1;
43494 }
43495 return resultobj;
43496 fail:
43497 {
43498 if (temp1)
43499 delete arg1;
43500 }
43501 return NULL;
43502 }
43503
43504
43505 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43506 PyObject *resultobj = 0;
43507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43508 wxItemKind result;
43509 void *argp1 = 0 ;
43510 int res1 = 0 ;
43511 PyObject *swig_obj[1] ;
43512
43513 if (!args) SWIG_fail;
43514 swig_obj[0] = args;
43515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43516 if (!SWIG_IsOK(res1)) {
43517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43518 }
43519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43520 {
43521 PyThreadState* __tstate = wxPyBeginAllowThreads();
43522 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43523 wxPyEndAllowThreads(__tstate);
43524 if (PyErr_Occurred()) SWIG_fail;
43525 }
43526 resultobj = SWIG_From_int(static_cast< int >(result));
43527 return resultobj;
43528 fail:
43529 return NULL;
43530 }
43531
43532
43533 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43534 PyObject *resultobj = 0;
43535 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43536 wxItemKind arg2 ;
43537 void *argp1 = 0 ;
43538 int res1 = 0 ;
43539 int val2 ;
43540 int ecode2 = 0 ;
43541 PyObject * obj0 = 0 ;
43542 PyObject * obj1 = 0 ;
43543 char * kwnames[] = {
43544 (char *) "self",(char *) "kind", NULL
43545 };
43546
43547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43549 if (!SWIG_IsOK(res1)) {
43550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43551 }
43552 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43553 ecode2 = SWIG_AsVal_int(obj1, &val2);
43554 if (!SWIG_IsOK(ecode2)) {
43555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43556 }
43557 arg2 = static_cast< wxItemKind >(val2);
43558 {
43559 PyThreadState* __tstate = wxPyBeginAllowThreads();
43560 (arg1)->SetKind(arg2);
43561 wxPyEndAllowThreads(__tstate);
43562 if (PyErr_Occurred()) SWIG_fail;
43563 }
43564 resultobj = SWIG_Py_Void();
43565 return resultobj;
43566 fail:
43567 return NULL;
43568 }
43569
43570
43571 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43572 PyObject *resultobj = 0;
43573 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43574 bool arg2 ;
43575 void *argp1 = 0 ;
43576 int res1 = 0 ;
43577 bool val2 ;
43578 int ecode2 = 0 ;
43579 PyObject * obj0 = 0 ;
43580 PyObject * obj1 = 0 ;
43581 char * kwnames[] = {
43582 (char *) "self",(char *) "checkable", NULL
43583 };
43584
43585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43587 if (!SWIG_IsOK(res1)) {
43588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43589 }
43590 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43592 if (!SWIG_IsOK(ecode2)) {
43593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43594 }
43595 arg2 = static_cast< bool >(val2);
43596 {
43597 PyThreadState* __tstate = wxPyBeginAllowThreads();
43598 (arg1)->SetCheckable(arg2);
43599 wxPyEndAllowThreads(__tstate);
43600 if (PyErr_Occurred()) SWIG_fail;
43601 }
43602 resultobj = SWIG_Py_Void();
43603 return resultobj;
43604 fail:
43605 return NULL;
43606 }
43607
43608
43609 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43610 PyObject *resultobj = 0;
43611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43612 bool result;
43613 void *argp1 = 0 ;
43614 int res1 = 0 ;
43615 PyObject *swig_obj[1] ;
43616
43617 if (!args) SWIG_fail;
43618 swig_obj[0] = args;
43619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43620 if (!SWIG_IsOK(res1)) {
43621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43622 }
43623 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43624 {
43625 PyThreadState* __tstate = wxPyBeginAllowThreads();
43626 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43627 wxPyEndAllowThreads(__tstate);
43628 if (PyErr_Occurred()) SWIG_fail;
43629 }
43630 {
43631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43632 }
43633 return resultobj;
43634 fail:
43635 return NULL;
43636 }
43637
43638
43639 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43640 PyObject *resultobj = 0;
43641 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43642 bool result;
43643 void *argp1 = 0 ;
43644 int res1 = 0 ;
43645 PyObject *swig_obj[1] ;
43646
43647 if (!args) SWIG_fail;
43648 swig_obj[0] = args;
43649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43650 if (!SWIG_IsOK(res1)) {
43651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43652 }
43653 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43654 {
43655 PyThreadState* __tstate = wxPyBeginAllowThreads();
43656 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43657 wxPyEndAllowThreads(__tstate);
43658 if (PyErr_Occurred()) SWIG_fail;
43659 }
43660 {
43661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43662 }
43663 return resultobj;
43664 fail:
43665 return NULL;
43666 }
43667
43668
43669 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43670 PyObject *resultobj = 0;
43671 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43672 wxMenu *arg2 = (wxMenu *) 0 ;
43673 void *argp1 = 0 ;
43674 int res1 = 0 ;
43675 void *argp2 = 0 ;
43676 int res2 = 0 ;
43677 PyObject * obj0 = 0 ;
43678 PyObject * obj1 = 0 ;
43679 char * kwnames[] = {
43680 (char *) "self",(char *) "menu", NULL
43681 };
43682
43683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43685 if (!SWIG_IsOK(res1)) {
43686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43687 }
43688 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43690 if (!SWIG_IsOK(res2)) {
43691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43692 }
43693 arg2 = reinterpret_cast< wxMenu * >(argp2);
43694 {
43695 PyThreadState* __tstate = wxPyBeginAllowThreads();
43696 (arg1)->SetSubMenu(arg2);
43697 wxPyEndAllowThreads(__tstate);
43698 if (PyErr_Occurred()) SWIG_fail;
43699 }
43700 resultobj = SWIG_Py_Void();
43701 return resultobj;
43702 fail:
43703 return NULL;
43704 }
43705
43706
43707 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43708 PyObject *resultobj = 0;
43709 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43710 wxMenu *result = 0 ;
43711 void *argp1 = 0 ;
43712 int res1 = 0 ;
43713 PyObject *swig_obj[1] ;
43714
43715 if (!args) SWIG_fail;
43716 swig_obj[0] = args;
43717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43718 if (!SWIG_IsOK(res1)) {
43719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43720 }
43721 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43722 {
43723 PyThreadState* __tstate = wxPyBeginAllowThreads();
43724 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43725 wxPyEndAllowThreads(__tstate);
43726 if (PyErr_Occurred()) SWIG_fail;
43727 }
43728 {
43729 resultobj = wxPyMake_wxObject(result, 0);
43730 }
43731 return resultobj;
43732 fail:
43733 return NULL;
43734 }
43735
43736
43737 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43738 PyObject *resultobj = 0;
43739 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43740 bool arg2 = (bool) true ;
43741 void *argp1 = 0 ;
43742 int res1 = 0 ;
43743 bool val2 ;
43744 int ecode2 = 0 ;
43745 PyObject * obj0 = 0 ;
43746 PyObject * obj1 = 0 ;
43747 char * kwnames[] = {
43748 (char *) "self",(char *) "enable", NULL
43749 };
43750
43751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43753 if (!SWIG_IsOK(res1)) {
43754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43755 }
43756 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43757 if (obj1) {
43758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43759 if (!SWIG_IsOK(ecode2)) {
43760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43761 }
43762 arg2 = static_cast< bool >(val2);
43763 }
43764 {
43765 PyThreadState* __tstate = wxPyBeginAllowThreads();
43766 (arg1)->Enable(arg2);
43767 wxPyEndAllowThreads(__tstate);
43768 if (PyErr_Occurred()) SWIG_fail;
43769 }
43770 resultobj = SWIG_Py_Void();
43771 return resultobj;
43772 fail:
43773 return NULL;
43774 }
43775
43776
43777 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43778 PyObject *resultobj = 0;
43779 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43780 bool result;
43781 void *argp1 = 0 ;
43782 int res1 = 0 ;
43783 PyObject *swig_obj[1] ;
43784
43785 if (!args) SWIG_fail;
43786 swig_obj[0] = args;
43787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43788 if (!SWIG_IsOK(res1)) {
43789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43790 }
43791 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43792 {
43793 PyThreadState* __tstate = wxPyBeginAllowThreads();
43794 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43795 wxPyEndAllowThreads(__tstate);
43796 if (PyErr_Occurred()) SWIG_fail;
43797 }
43798 {
43799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43800 }
43801 return resultobj;
43802 fail:
43803 return NULL;
43804 }
43805
43806
43807 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43808 PyObject *resultobj = 0;
43809 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43810 bool arg2 = (bool) true ;
43811 void *argp1 = 0 ;
43812 int res1 = 0 ;
43813 bool val2 ;
43814 int ecode2 = 0 ;
43815 PyObject * obj0 = 0 ;
43816 PyObject * obj1 = 0 ;
43817 char * kwnames[] = {
43818 (char *) "self",(char *) "check", NULL
43819 };
43820
43821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43823 if (!SWIG_IsOK(res1)) {
43824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43825 }
43826 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43827 if (obj1) {
43828 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43829 if (!SWIG_IsOK(ecode2)) {
43830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43831 }
43832 arg2 = static_cast< bool >(val2);
43833 }
43834 {
43835 PyThreadState* __tstate = wxPyBeginAllowThreads();
43836 (arg1)->Check(arg2);
43837 wxPyEndAllowThreads(__tstate);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 }
43840 resultobj = SWIG_Py_Void();
43841 return resultobj;
43842 fail:
43843 return NULL;
43844 }
43845
43846
43847 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43848 PyObject *resultobj = 0;
43849 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43850 bool result;
43851 void *argp1 = 0 ;
43852 int res1 = 0 ;
43853 PyObject *swig_obj[1] ;
43854
43855 if (!args) SWIG_fail;
43856 swig_obj[0] = args;
43857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43858 if (!SWIG_IsOK(res1)) {
43859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43860 }
43861 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43865 wxPyEndAllowThreads(__tstate);
43866 if (PyErr_Occurred()) SWIG_fail;
43867 }
43868 {
43869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43870 }
43871 return resultobj;
43872 fail:
43873 return NULL;
43874 }
43875
43876
43877 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43878 PyObject *resultobj = 0;
43879 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43880 void *argp1 = 0 ;
43881 int res1 = 0 ;
43882 PyObject *swig_obj[1] ;
43883
43884 if (!args) SWIG_fail;
43885 swig_obj[0] = args;
43886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43887 if (!SWIG_IsOK(res1)) {
43888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43889 }
43890 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43891 {
43892 PyThreadState* __tstate = wxPyBeginAllowThreads();
43893 (arg1)->Toggle();
43894 wxPyEndAllowThreads(__tstate);
43895 if (PyErr_Occurred()) SWIG_fail;
43896 }
43897 resultobj = SWIG_Py_Void();
43898 return resultobj;
43899 fail:
43900 return NULL;
43901 }
43902
43903
43904 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43905 PyObject *resultobj = 0;
43906 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43907 wxString *arg2 = 0 ;
43908 void *argp1 = 0 ;
43909 int res1 = 0 ;
43910 bool temp2 = false ;
43911 PyObject * obj0 = 0 ;
43912 PyObject * obj1 = 0 ;
43913 char * kwnames[] = {
43914 (char *) "self",(char *) "str", NULL
43915 };
43916
43917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43919 if (!SWIG_IsOK(res1)) {
43920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43921 }
43922 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43923 {
43924 arg2 = wxString_in_helper(obj1);
43925 if (arg2 == NULL) SWIG_fail;
43926 temp2 = true;
43927 }
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 (arg1)->SetHelp((wxString const &)*arg2);
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_Py_Void();
43935 {
43936 if (temp2)
43937 delete arg2;
43938 }
43939 return resultobj;
43940 fail:
43941 {
43942 if (temp2)
43943 delete arg2;
43944 }
43945 return NULL;
43946 }
43947
43948
43949 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43950 PyObject *resultobj = 0;
43951 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43952 wxString *result = 0 ;
43953 void *argp1 = 0 ;
43954 int res1 = 0 ;
43955 PyObject *swig_obj[1] ;
43956
43957 if (!args) SWIG_fail;
43958 swig_obj[0] = args;
43959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43960 if (!SWIG_IsOK(res1)) {
43961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43962 }
43963 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43964 {
43965 PyThreadState* __tstate = wxPyBeginAllowThreads();
43966 {
43967 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43968 result = (wxString *) &_result_ref;
43969 }
43970 wxPyEndAllowThreads(__tstate);
43971 if (PyErr_Occurred()) SWIG_fail;
43972 }
43973 {
43974 #if wxUSE_UNICODE
43975 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43976 #else
43977 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43978 #endif
43979 }
43980 return resultobj;
43981 fail:
43982 return NULL;
43983 }
43984
43985
43986 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43987 PyObject *resultobj = 0;
43988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43989 wxAcceleratorEntry *result = 0 ;
43990 void *argp1 = 0 ;
43991 int res1 = 0 ;
43992 PyObject *swig_obj[1] ;
43993
43994 if (!args) SWIG_fail;
43995 swig_obj[0] = args;
43996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43997 if (!SWIG_IsOK(res1)) {
43998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43999 }
44000 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44001 {
44002 PyThreadState* __tstate = wxPyBeginAllowThreads();
44003 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44004 wxPyEndAllowThreads(__tstate);
44005 if (PyErr_Occurred()) SWIG_fail;
44006 }
44007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44008 return resultobj;
44009 fail:
44010 return NULL;
44011 }
44012
44013
44014 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44015 PyObject *resultobj = 0;
44016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44017 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44018 void *argp1 = 0 ;
44019 int res1 = 0 ;
44020 void *argp2 = 0 ;
44021 int res2 = 0 ;
44022 PyObject * obj0 = 0 ;
44023 PyObject * obj1 = 0 ;
44024 char * kwnames[] = {
44025 (char *) "self",(char *) "accel", NULL
44026 };
44027
44028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44030 if (!SWIG_IsOK(res1)) {
44031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44032 }
44033 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44035 if (!SWIG_IsOK(res2)) {
44036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44037 }
44038 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44039 {
44040 PyThreadState* __tstate = wxPyBeginAllowThreads();
44041 (arg1)->SetAccel(arg2);
44042 wxPyEndAllowThreads(__tstate);
44043 if (PyErr_Occurred()) SWIG_fail;
44044 }
44045 resultobj = SWIG_Py_Void();
44046 return resultobj;
44047 fail:
44048 return NULL;
44049 }
44050
44051
44052 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44053 PyObject *resultobj = 0;
44054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44055 wxBitmap *arg2 = 0 ;
44056 void *argp1 = 0 ;
44057 int res1 = 0 ;
44058 void *argp2 = 0 ;
44059 int res2 = 0 ;
44060 PyObject * obj0 = 0 ;
44061 PyObject * obj1 = 0 ;
44062 char * kwnames[] = {
44063 (char *) "self",(char *) "bitmap", NULL
44064 };
44065
44066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44068 if (!SWIG_IsOK(res1)) {
44069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44070 }
44071 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44072 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44073 if (!SWIG_IsOK(res2)) {
44074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44075 }
44076 if (!argp2) {
44077 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44078 }
44079 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44080 {
44081 PyThreadState* __tstate = wxPyBeginAllowThreads();
44082 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44083 wxPyEndAllowThreads(__tstate);
44084 if (PyErr_Occurred()) SWIG_fail;
44085 }
44086 resultobj = SWIG_Py_Void();
44087 return resultobj;
44088 fail:
44089 return NULL;
44090 }
44091
44092
44093 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44094 PyObject *resultobj = 0;
44095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44096 wxBitmap *result = 0 ;
44097 void *argp1 = 0 ;
44098 int res1 = 0 ;
44099 PyObject *swig_obj[1] ;
44100
44101 if (!args) SWIG_fail;
44102 swig_obj[0] = args;
44103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44104 if (!SWIG_IsOK(res1)) {
44105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44106 }
44107 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44108 {
44109 PyThreadState* __tstate = wxPyBeginAllowThreads();
44110 {
44111 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44112 result = (wxBitmap *) &_result_ref;
44113 }
44114 wxPyEndAllowThreads(__tstate);
44115 if (PyErr_Occurred()) SWIG_fail;
44116 }
44117 {
44118 wxBitmap* resultptr = new wxBitmap(*result);
44119 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44120 }
44121 return resultobj;
44122 fail:
44123 return NULL;
44124 }
44125
44126
44127 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44128 PyObject *resultobj = 0;
44129 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44130 wxFont *arg2 = 0 ;
44131 void *argp1 = 0 ;
44132 int res1 = 0 ;
44133 void *argp2 = 0 ;
44134 int res2 = 0 ;
44135 PyObject * obj0 = 0 ;
44136 PyObject * obj1 = 0 ;
44137 char * kwnames[] = {
44138 (char *) "self",(char *) "font", NULL
44139 };
44140
44141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44143 if (!SWIG_IsOK(res1)) {
44144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44145 }
44146 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44148 if (!SWIG_IsOK(res2)) {
44149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44150 }
44151 if (!argp2) {
44152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44153 }
44154 arg2 = reinterpret_cast< wxFont * >(argp2);
44155 {
44156 PyThreadState* __tstate = wxPyBeginAllowThreads();
44157 (arg1)->SetFont((wxFont const &)*arg2);
44158 wxPyEndAllowThreads(__tstate);
44159 if (PyErr_Occurred()) SWIG_fail;
44160 }
44161 resultobj = SWIG_Py_Void();
44162 return resultobj;
44163 fail:
44164 return NULL;
44165 }
44166
44167
44168 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44169 PyObject *resultobj = 0;
44170 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44171 wxFont result;
44172 void *argp1 = 0 ;
44173 int res1 = 0 ;
44174 PyObject *swig_obj[1] ;
44175
44176 if (!args) SWIG_fail;
44177 swig_obj[0] = args;
44178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44179 if (!SWIG_IsOK(res1)) {
44180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44181 }
44182 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44183 {
44184 PyThreadState* __tstate = wxPyBeginAllowThreads();
44185 result = (arg1)->GetFont();
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44197 PyObject *resultobj = 0;
44198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44199 wxColour *arg2 = 0 ;
44200 void *argp1 = 0 ;
44201 int res1 = 0 ;
44202 wxColour temp2 ;
44203 PyObject * obj0 = 0 ;
44204 PyObject * obj1 = 0 ;
44205 char * kwnames[] = {
44206 (char *) "self",(char *) "colText", NULL
44207 };
44208
44209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44211 if (!SWIG_IsOK(res1)) {
44212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44213 }
44214 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44215 {
44216 arg2 = &temp2;
44217 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44218 }
44219 {
44220 PyThreadState* __tstate = wxPyBeginAllowThreads();
44221 (arg1)->SetTextColour((wxColour const &)*arg2);
44222 wxPyEndAllowThreads(__tstate);
44223 if (PyErr_Occurred()) SWIG_fail;
44224 }
44225 resultobj = SWIG_Py_Void();
44226 return resultobj;
44227 fail:
44228 return NULL;
44229 }
44230
44231
44232 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44233 PyObject *resultobj = 0;
44234 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44235 wxColour result;
44236 void *argp1 = 0 ;
44237 int res1 = 0 ;
44238 PyObject *swig_obj[1] ;
44239
44240 if (!args) SWIG_fail;
44241 swig_obj[0] = args;
44242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44243 if (!SWIG_IsOK(res1)) {
44244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44245 }
44246 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44247 {
44248 PyThreadState* __tstate = wxPyBeginAllowThreads();
44249 result = (arg1)->GetTextColour();
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44254 return resultobj;
44255 fail:
44256 return NULL;
44257 }
44258
44259
44260 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44261 PyObject *resultobj = 0;
44262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44263 wxColour *arg2 = 0 ;
44264 void *argp1 = 0 ;
44265 int res1 = 0 ;
44266 wxColour temp2 ;
44267 PyObject * obj0 = 0 ;
44268 PyObject * obj1 = 0 ;
44269 char * kwnames[] = {
44270 (char *) "self",(char *) "colBack", NULL
44271 };
44272
44273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44275 if (!SWIG_IsOK(res1)) {
44276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44277 }
44278 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44279 {
44280 arg2 = &temp2;
44281 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44282 }
44283 {
44284 PyThreadState* __tstate = wxPyBeginAllowThreads();
44285 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44286 wxPyEndAllowThreads(__tstate);
44287 if (PyErr_Occurred()) SWIG_fail;
44288 }
44289 resultobj = SWIG_Py_Void();
44290 return resultobj;
44291 fail:
44292 return NULL;
44293 }
44294
44295
44296 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44297 PyObject *resultobj = 0;
44298 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44299 wxColour result;
44300 void *argp1 = 0 ;
44301 int res1 = 0 ;
44302 PyObject *swig_obj[1] ;
44303
44304 if (!args) SWIG_fail;
44305 swig_obj[0] = args;
44306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44307 if (!SWIG_IsOK(res1)) {
44308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44309 }
44310 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44311 {
44312 PyThreadState* __tstate = wxPyBeginAllowThreads();
44313 result = (arg1)->GetBackgroundColour();
44314 wxPyEndAllowThreads(__tstate);
44315 if (PyErr_Occurred()) SWIG_fail;
44316 }
44317 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44318 return resultobj;
44319 fail:
44320 return NULL;
44321 }
44322
44323
44324 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44325 PyObject *resultobj = 0;
44326 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44327 wxBitmap *arg2 = 0 ;
44328 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44329 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44330 void *argp1 = 0 ;
44331 int res1 = 0 ;
44332 void *argp2 = 0 ;
44333 int res2 = 0 ;
44334 void *argp3 = 0 ;
44335 int res3 = 0 ;
44336 PyObject * obj0 = 0 ;
44337 PyObject * obj1 = 0 ;
44338 PyObject * obj2 = 0 ;
44339 char * kwnames[] = {
44340 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44341 };
44342
44343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44345 if (!SWIG_IsOK(res1)) {
44346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44347 }
44348 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44350 if (!SWIG_IsOK(res2)) {
44351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44352 }
44353 if (!argp2) {
44354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44355 }
44356 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44357 if (obj2) {
44358 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44359 if (!SWIG_IsOK(res3)) {
44360 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44361 }
44362 if (!argp3) {
44363 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44364 }
44365 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44366 }
44367 {
44368 PyThreadState* __tstate = wxPyBeginAllowThreads();
44369 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44370 wxPyEndAllowThreads(__tstate);
44371 if (PyErr_Occurred()) SWIG_fail;
44372 }
44373 resultobj = SWIG_Py_Void();
44374 return resultobj;
44375 fail:
44376 return NULL;
44377 }
44378
44379
44380 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44381 PyObject *resultobj = 0;
44382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44383 wxBitmap *arg2 = 0 ;
44384 void *argp1 = 0 ;
44385 int res1 = 0 ;
44386 void *argp2 = 0 ;
44387 int res2 = 0 ;
44388 PyObject * obj0 = 0 ;
44389 PyObject * obj1 = 0 ;
44390 char * kwnames[] = {
44391 (char *) "self",(char *) "bmpDisabled", NULL
44392 };
44393
44394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44396 if (!SWIG_IsOK(res1)) {
44397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44398 }
44399 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44400 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44401 if (!SWIG_IsOK(res2)) {
44402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44403 }
44404 if (!argp2) {
44405 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44406 }
44407 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44408 {
44409 PyThreadState* __tstate = wxPyBeginAllowThreads();
44410 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44411 wxPyEndAllowThreads(__tstate);
44412 if (PyErr_Occurred()) SWIG_fail;
44413 }
44414 resultobj = SWIG_Py_Void();
44415 return resultobj;
44416 fail:
44417 return NULL;
44418 }
44419
44420
44421 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44422 PyObject *resultobj = 0;
44423 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44424 wxBitmap *result = 0 ;
44425 void *argp1 = 0 ;
44426 int res1 = 0 ;
44427 PyObject *swig_obj[1] ;
44428
44429 if (!args) SWIG_fail;
44430 swig_obj[0] = args;
44431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44432 if (!SWIG_IsOK(res1)) {
44433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44434 }
44435 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44436 {
44437 PyThreadState* __tstate = wxPyBeginAllowThreads();
44438 {
44439 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44440 result = (wxBitmap *) &_result_ref;
44441 }
44442 wxPyEndAllowThreads(__tstate);
44443 if (PyErr_Occurred()) SWIG_fail;
44444 }
44445 {
44446 wxBitmap* resultptr = new wxBitmap(*result);
44447 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44448 }
44449 return resultobj;
44450 fail:
44451 return NULL;
44452 }
44453
44454
44455 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44456 PyObject *resultobj = 0;
44457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44458 int arg2 ;
44459 void *argp1 = 0 ;
44460 int res1 = 0 ;
44461 int val2 ;
44462 int ecode2 = 0 ;
44463 PyObject * obj0 = 0 ;
44464 PyObject * obj1 = 0 ;
44465 char * kwnames[] = {
44466 (char *) "self",(char *) "nWidth", NULL
44467 };
44468
44469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44471 if (!SWIG_IsOK(res1)) {
44472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44473 }
44474 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44475 ecode2 = SWIG_AsVal_int(obj1, &val2);
44476 if (!SWIG_IsOK(ecode2)) {
44477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44478 }
44479 arg2 = static_cast< int >(val2);
44480 {
44481 PyThreadState* __tstate = wxPyBeginAllowThreads();
44482 (arg1)->SetMarginWidth(arg2);
44483 wxPyEndAllowThreads(__tstate);
44484 if (PyErr_Occurred()) SWIG_fail;
44485 }
44486 resultobj = SWIG_Py_Void();
44487 return resultobj;
44488 fail:
44489 return NULL;
44490 }
44491
44492
44493 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44494 PyObject *resultobj = 0;
44495 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44496 int result;
44497 void *argp1 = 0 ;
44498 int res1 = 0 ;
44499 PyObject *swig_obj[1] ;
44500
44501 if (!args) SWIG_fail;
44502 swig_obj[0] = args;
44503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44504 if (!SWIG_IsOK(res1)) {
44505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44506 }
44507 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44508 {
44509 PyThreadState* __tstate = wxPyBeginAllowThreads();
44510 result = (int)(arg1)->GetMarginWidth();
44511 wxPyEndAllowThreads(__tstate);
44512 if (PyErr_Occurred()) SWIG_fail;
44513 }
44514 resultobj = SWIG_From_int(static_cast< int >(result));
44515 return resultobj;
44516 fail:
44517 return NULL;
44518 }
44519
44520
44521 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44522 PyObject *resultobj = 0;
44523 int result;
44524
44525 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44526 {
44527 PyThreadState* __tstate = wxPyBeginAllowThreads();
44528 result = (int)wxMenuItem::GetDefaultMarginWidth();
44529 wxPyEndAllowThreads(__tstate);
44530 if (PyErr_Occurred()) SWIG_fail;
44531 }
44532 resultobj = SWIG_From_int(static_cast< int >(result));
44533 return resultobj;
44534 fail:
44535 return NULL;
44536 }
44537
44538
44539 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44540 PyObject *resultobj = 0;
44541 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44542 bool result;
44543 void *argp1 = 0 ;
44544 int res1 = 0 ;
44545 PyObject *swig_obj[1] ;
44546
44547 if (!args) SWIG_fail;
44548 swig_obj[0] = args;
44549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44550 if (!SWIG_IsOK(res1)) {
44551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44552 }
44553 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44554 {
44555 PyThreadState* __tstate = wxPyBeginAllowThreads();
44556 result = (bool)(arg1)->IsOwnerDrawn();
44557 wxPyEndAllowThreads(__tstate);
44558 if (PyErr_Occurred()) SWIG_fail;
44559 }
44560 {
44561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44562 }
44563 return resultobj;
44564 fail:
44565 return NULL;
44566 }
44567
44568
44569 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44570 PyObject *resultobj = 0;
44571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44572 bool arg2 = (bool) true ;
44573 void *argp1 = 0 ;
44574 int res1 = 0 ;
44575 bool val2 ;
44576 int ecode2 = 0 ;
44577 PyObject * obj0 = 0 ;
44578 PyObject * obj1 = 0 ;
44579 char * kwnames[] = {
44580 (char *) "self",(char *) "ownerDrawn", NULL
44581 };
44582
44583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44585 if (!SWIG_IsOK(res1)) {
44586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44587 }
44588 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44589 if (obj1) {
44590 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44591 if (!SWIG_IsOK(ecode2)) {
44592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44593 }
44594 arg2 = static_cast< bool >(val2);
44595 }
44596 {
44597 PyThreadState* __tstate = wxPyBeginAllowThreads();
44598 (arg1)->SetOwnerDrawn(arg2);
44599 wxPyEndAllowThreads(__tstate);
44600 if (PyErr_Occurred()) SWIG_fail;
44601 }
44602 resultobj = SWIG_Py_Void();
44603 return resultobj;
44604 fail:
44605 return NULL;
44606 }
44607
44608
44609 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44610 PyObject *resultobj = 0;
44611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44612 void *argp1 = 0 ;
44613 int res1 = 0 ;
44614 PyObject *swig_obj[1] ;
44615
44616 if (!args) SWIG_fail;
44617 swig_obj[0] = args;
44618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44619 if (!SWIG_IsOK(res1)) {
44620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44621 }
44622 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44623 {
44624 PyThreadState* __tstate = wxPyBeginAllowThreads();
44625 (arg1)->ResetOwnerDrawn();
44626 wxPyEndAllowThreads(__tstate);
44627 if (PyErr_Occurred()) SWIG_fail;
44628 }
44629 resultobj = SWIG_Py_Void();
44630 return resultobj;
44631 fail:
44632 return NULL;
44633 }
44634
44635
44636 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44637 PyObject *obj;
44638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44639 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44640 return SWIG_Py_Void();
44641 }
44642
44643 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44644 return SWIG_Python_InitShadowInstance(args);
44645 }
44646
44647 SWIGINTERN int ControlNameStr_set(PyObject *) {
44648 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44649 return 1;
44650 }
44651
44652
44653 SWIGINTERN PyObject *ControlNameStr_get(void) {
44654 PyObject *pyobj = 0;
44655
44656 {
44657 #if wxUSE_UNICODE
44658 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44659 #else
44660 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44661 #endif
44662 }
44663 return pyobj;
44664 }
44665
44666
44667 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44668 PyObject *resultobj = 0;
44669 wxWindow *arg1 = (wxWindow *) 0 ;
44670 int arg2 = (int) -1 ;
44671 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44672 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44673 wxSize const &arg4_defvalue = wxDefaultSize ;
44674 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44675 long arg5 = (long) 0 ;
44676 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44677 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44678 wxString const &arg7_defvalue = wxPyControlNameStr ;
44679 wxString *arg7 = (wxString *) &arg7_defvalue ;
44680 wxControl *result = 0 ;
44681 void *argp1 = 0 ;
44682 int res1 = 0 ;
44683 int val2 ;
44684 int ecode2 = 0 ;
44685 wxPoint temp3 ;
44686 wxSize temp4 ;
44687 long val5 ;
44688 int ecode5 = 0 ;
44689 void *argp6 = 0 ;
44690 int res6 = 0 ;
44691 bool temp7 = false ;
44692 PyObject * obj0 = 0 ;
44693 PyObject * obj1 = 0 ;
44694 PyObject * obj2 = 0 ;
44695 PyObject * obj3 = 0 ;
44696 PyObject * obj4 = 0 ;
44697 PyObject * obj5 = 0 ;
44698 PyObject * obj6 = 0 ;
44699 char * kwnames[] = {
44700 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44701 };
44702
44703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44705 if (!SWIG_IsOK(res1)) {
44706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44707 }
44708 arg1 = reinterpret_cast< wxWindow * >(argp1);
44709 if (obj1) {
44710 ecode2 = SWIG_AsVal_int(obj1, &val2);
44711 if (!SWIG_IsOK(ecode2)) {
44712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44713 }
44714 arg2 = static_cast< int >(val2);
44715 }
44716 if (obj2) {
44717 {
44718 arg3 = &temp3;
44719 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44720 }
44721 }
44722 if (obj3) {
44723 {
44724 arg4 = &temp4;
44725 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44726 }
44727 }
44728 if (obj4) {
44729 ecode5 = SWIG_AsVal_long(obj4, &val5);
44730 if (!SWIG_IsOK(ecode5)) {
44731 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44732 }
44733 arg5 = static_cast< long >(val5);
44734 }
44735 if (obj5) {
44736 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44737 if (!SWIG_IsOK(res6)) {
44738 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44739 }
44740 if (!argp6) {
44741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44742 }
44743 arg6 = reinterpret_cast< wxValidator * >(argp6);
44744 }
44745 if (obj6) {
44746 {
44747 arg7 = wxString_in_helper(obj6);
44748 if (arg7 == NULL) SWIG_fail;
44749 temp7 = true;
44750 }
44751 }
44752 {
44753 if (!wxPyCheckForApp()) SWIG_fail;
44754 PyThreadState* __tstate = wxPyBeginAllowThreads();
44755 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44756 wxPyEndAllowThreads(__tstate);
44757 if (PyErr_Occurred()) SWIG_fail;
44758 }
44759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44760 {
44761 if (temp7)
44762 delete arg7;
44763 }
44764 return resultobj;
44765 fail:
44766 {
44767 if (temp7)
44768 delete arg7;
44769 }
44770 return NULL;
44771 }
44772
44773
44774 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44775 PyObject *resultobj = 0;
44776 wxControl *result = 0 ;
44777
44778 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44779 {
44780 if (!wxPyCheckForApp()) SWIG_fail;
44781 PyThreadState* __tstate = wxPyBeginAllowThreads();
44782 result = (wxControl *)new wxControl();
44783 wxPyEndAllowThreads(__tstate);
44784 if (PyErr_Occurred()) SWIG_fail;
44785 }
44786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44787 return resultobj;
44788 fail:
44789 return NULL;
44790 }
44791
44792
44793 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44794 PyObject *resultobj = 0;
44795 wxControl *arg1 = (wxControl *) 0 ;
44796 wxWindow *arg2 = (wxWindow *) 0 ;
44797 int arg3 = (int) -1 ;
44798 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44799 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44800 wxSize const &arg5_defvalue = wxDefaultSize ;
44801 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44802 long arg6 = (long) 0 ;
44803 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44804 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44805 wxString const &arg8_defvalue = wxPyControlNameStr ;
44806 wxString *arg8 = (wxString *) &arg8_defvalue ;
44807 bool result;
44808 void *argp1 = 0 ;
44809 int res1 = 0 ;
44810 void *argp2 = 0 ;
44811 int res2 = 0 ;
44812 int val3 ;
44813 int ecode3 = 0 ;
44814 wxPoint temp4 ;
44815 wxSize temp5 ;
44816 long val6 ;
44817 int ecode6 = 0 ;
44818 void *argp7 = 0 ;
44819 int res7 = 0 ;
44820 bool temp8 = false ;
44821 PyObject * obj0 = 0 ;
44822 PyObject * obj1 = 0 ;
44823 PyObject * obj2 = 0 ;
44824 PyObject * obj3 = 0 ;
44825 PyObject * obj4 = 0 ;
44826 PyObject * obj5 = 0 ;
44827 PyObject * obj6 = 0 ;
44828 PyObject * obj7 = 0 ;
44829 char * kwnames[] = {
44830 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44831 };
44832
44833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44835 if (!SWIG_IsOK(res1)) {
44836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44837 }
44838 arg1 = reinterpret_cast< wxControl * >(argp1);
44839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44840 if (!SWIG_IsOK(res2)) {
44841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44842 }
44843 arg2 = reinterpret_cast< wxWindow * >(argp2);
44844 if (obj2) {
44845 ecode3 = SWIG_AsVal_int(obj2, &val3);
44846 if (!SWIG_IsOK(ecode3)) {
44847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44848 }
44849 arg3 = static_cast< int >(val3);
44850 }
44851 if (obj3) {
44852 {
44853 arg4 = &temp4;
44854 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44855 }
44856 }
44857 if (obj4) {
44858 {
44859 arg5 = &temp5;
44860 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44861 }
44862 }
44863 if (obj5) {
44864 ecode6 = SWIG_AsVal_long(obj5, &val6);
44865 if (!SWIG_IsOK(ecode6)) {
44866 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44867 }
44868 arg6 = static_cast< long >(val6);
44869 }
44870 if (obj6) {
44871 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44872 if (!SWIG_IsOK(res7)) {
44873 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44874 }
44875 if (!argp7) {
44876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44877 }
44878 arg7 = reinterpret_cast< wxValidator * >(argp7);
44879 }
44880 if (obj7) {
44881 {
44882 arg8 = wxString_in_helper(obj7);
44883 if (arg8 == NULL) SWIG_fail;
44884 temp8 = true;
44885 }
44886 }
44887 {
44888 PyThreadState* __tstate = wxPyBeginAllowThreads();
44889 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44890 wxPyEndAllowThreads(__tstate);
44891 if (PyErr_Occurred()) SWIG_fail;
44892 }
44893 {
44894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44895 }
44896 {
44897 if (temp8)
44898 delete arg8;
44899 }
44900 return resultobj;
44901 fail:
44902 {
44903 if (temp8)
44904 delete arg8;
44905 }
44906 return NULL;
44907 }
44908
44909
44910 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44911 PyObject *resultobj = 0;
44912 wxControl *arg1 = (wxControl *) 0 ;
44913 int result;
44914 void *argp1 = 0 ;
44915 int res1 = 0 ;
44916 PyObject *swig_obj[1] ;
44917
44918 if (!args) SWIG_fail;
44919 swig_obj[0] = args;
44920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44921 if (!SWIG_IsOK(res1)) {
44922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44923 }
44924 arg1 = reinterpret_cast< wxControl * >(argp1);
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 result = (int)((wxControl const *)arg1)->GetAlignment();
44928 wxPyEndAllowThreads(__tstate);
44929 if (PyErr_Occurred()) SWIG_fail;
44930 }
44931 resultobj = SWIG_From_int(static_cast< int >(result));
44932 return resultobj;
44933 fail:
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44939 PyObject *resultobj = 0;
44940 wxControl *arg1 = (wxControl *) 0 ;
44941 wxString result;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 PyObject *swig_obj[1] ;
44945
44946 if (!args) SWIG_fail;
44947 swig_obj[0] = args;
44948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44949 if (!SWIG_IsOK(res1)) {
44950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44951 }
44952 arg1 = reinterpret_cast< wxControl * >(argp1);
44953 {
44954 PyThreadState* __tstate = wxPyBeginAllowThreads();
44955 result = ((wxControl const *)arg1)->GetLabelText();
44956 wxPyEndAllowThreads(__tstate);
44957 if (PyErr_Occurred()) SWIG_fail;
44958 }
44959 {
44960 #if wxUSE_UNICODE
44961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44962 #else
44963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44964 #endif
44965 }
44966 return resultobj;
44967 fail:
44968 return NULL;
44969 }
44970
44971
44972 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44973 PyObject *resultobj = 0;
44974 wxControl *arg1 = (wxControl *) 0 ;
44975 wxCommandEvent *arg2 = 0 ;
44976 void *argp1 = 0 ;
44977 int res1 = 0 ;
44978 void *argp2 = 0 ;
44979 int res2 = 0 ;
44980 PyObject * obj0 = 0 ;
44981 PyObject * obj1 = 0 ;
44982 char * kwnames[] = {
44983 (char *) "self",(char *) "event", NULL
44984 };
44985
44986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44988 if (!SWIG_IsOK(res1)) {
44989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44990 }
44991 arg1 = reinterpret_cast< wxControl * >(argp1);
44992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44993 if (!SWIG_IsOK(res2)) {
44994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44995 }
44996 if (!argp2) {
44997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44998 }
44999 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45000 {
45001 PyThreadState* __tstate = wxPyBeginAllowThreads();
45002 (arg1)->Command(*arg2);
45003 wxPyEndAllowThreads(__tstate);
45004 if (PyErr_Occurred()) SWIG_fail;
45005 }
45006 resultobj = SWIG_Py_Void();
45007 return resultobj;
45008 fail:
45009 return NULL;
45010 }
45011
45012
45013 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45014 PyObject *resultobj = 0;
45015 wxControl *arg1 = (wxControl *) 0 ;
45016 wxString result;
45017 void *argp1 = 0 ;
45018 int res1 = 0 ;
45019 PyObject *swig_obj[1] ;
45020
45021 if (!args) SWIG_fail;
45022 swig_obj[0] = args;
45023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45024 if (!SWIG_IsOK(res1)) {
45025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
45026 }
45027 arg1 = reinterpret_cast< wxControl * >(argp1);
45028 {
45029 PyThreadState* __tstate = wxPyBeginAllowThreads();
45030 result = (arg1)->GetLabel();
45031 wxPyEndAllowThreads(__tstate);
45032 if (PyErr_Occurred()) SWIG_fail;
45033 }
45034 {
45035 #if wxUSE_UNICODE
45036 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45037 #else
45038 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45039 #endif
45040 }
45041 return resultobj;
45042 fail:
45043 return NULL;
45044 }
45045
45046
45047 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45048 PyObject *resultobj = 0;
45049 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45050 SwigValueWrapper<wxVisualAttributes > result;
45051 int val1 ;
45052 int ecode1 = 0 ;
45053 PyObject * obj0 = 0 ;
45054 char * kwnames[] = {
45055 (char *) "variant", NULL
45056 };
45057
45058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45059 if (obj0) {
45060 ecode1 = SWIG_AsVal_int(obj0, &val1);
45061 if (!SWIG_IsOK(ecode1)) {
45062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45063 }
45064 arg1 = static_cast< wxWindowVariant >(val1);
45065 }
45066 {
45067 if (!wxPyCheckForApp()) SWIG_fail;
45068 PyThreadState* __tstate = wxPyBeginAllowThreads();
45069 result = wxControl::GetClassDefaultAttributes(arg1);
45070 wxPyEndAllowThreads(__tstate);
45071 if (PyErr_Occurred()) SWIG_fail;
45072 }
45073 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45074 return resultobj;
45075 fail:
45076 return NULL;
45077 }
45078
45079
45080 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45081 PyObject *obj;
45082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45083 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45084 return SWIG_Py_Void();
45085 }
45086
45087 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45088 return SWIG_Python_InitShadowInstance(args);
45089 }
45090
45091 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45092 PyObject *resultobj = 0;
45093 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45094 wxString *arg2 = 0 ;
45095 PyObject *arg3 = (PyObject *) NULL ;
45096 int result;
45097 void *argp1 = 0 ;
45098 int res1 = 0 ;
45099 bool temp2 = false ;
45100 PyObject * obj0 = 0 ;
45101 PyObject * obj1 = 0 ;
45102 PyObject * obj2 = 0 ;
45103 char * kwnames[] = {
45104 (char *) "self",(char *) "item",(char *) "clientData", NULL
45105 };
45106
45107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45109 if (!SWIG_IsOK(res1)) {
45110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45111 }
45112 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45113 {
45114 arg2 = wxString_in_helper(obj1);
45115 if (arg2 == NULL) SWIG_fail;
45116 temp2 = true;
45117 }
45118 if (obj2) {
45119 arg3 = obj2;
45120 }
45121 {
45122 PyThreadState* __tstate = wxPyBeginAllowThreads();
45123 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45124 wxPyEndAllowThreads(__tstate);
45125 if (PyErr_Occurred()) SWIG_fail;
45126 }
45127 resultobj = SWIG_From_int(static_cast< int >(result));
45128 {
45129 if (temp2)
45130 delete arg2;
45131 }
45132 return resultobj;
45133 fail:
45134 {
45135 if (temp2)
45136 delete arg2;
45137 }
45138 return NULL;
45139 }
45140
45141
45142 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45143 PyObject *resultobj = 0;
45144 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45145 wxArrayString *arg2 = 0 ;
45146 void *argp1 = 0 ;
45147 int res1 = 0 ;
45148 bool temp2 = false ;
45149 PyObject * obj0 = 0 ;
45150 PyObject * obj1 = 0 ;
45151 char * kwnames[] = {
45152 (char *) "self",(char *) "strings", NULL
45153 };
45154
45155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45157 if (!SWIG_IsOK(res1)) {
45158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45159 }
45160 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45161 {
45162 if (! PySequence_Check(obj1)) {
45163 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45164 SWIG_fail;
45165 }
45166 arg2 = new wxArrayString;
45167 temp2 = true;
45168 int i, len=PySequence_Length(obj1);
45169 for (i=0; i<len; i++) {
45170 PyObject* item = PySequence_GetItem(obj1, i);
45171 wxString* s = wxString_in_helper(item);
45172 if (PyErr_Occurred()) SWIG_fail;
45173 arg2->Add(*s);
45174 delete s;
45175 Py_DECREF(item);
45176 }
45177 }
45178 {
45179 PyThreadState* __tstate = wxPyBeginAllowThreads();
45180 (arg1)->Append((wxArrayString const &)*arg2);
45181 wxPyEndAllowThreads(__tstate);
45182 if (PyErr_Occurred()) SWIG_fail;
45183 }
45184 resultobj = SWIG_Py_Void();
45185 {
45186 if (temp2) delete arg2;
45187 }
45188 return resultobj;
45189 fail:
45190 {
45191 if (temp2) delete arg2;
45192 }
45193 return NULL;
45194 }
45195
45196
45197 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45198 PyObject *resultobj = 0;
45199 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45200 wxString *arg2 = 0 ;
45201 unsigned int arg3 ;
45202 PyObject *arg4 = (PyObject *) NULL ;
45203 int result;
45204 void *argp1 = 0 ;
45205 int res1 = 0 ;
45206 bool temp2 = false ;
45207 unsigned int val3 ;
45208 int ecode3 = 0 ;
45209 PyObject * obj0 = 0 ;
45210 PyObject * obj1 = 0 ;
45211 PyObject * obj2 = 0 ;
45212 PyObject * obj3 = 0 ;
45213 char * kwnames[] = {
45214 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45215 };
45216
45217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45219 if (!SWIG_IsOK(res1)) {
45220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45221 }
45222 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45223 {
45224 arg2 = wxString_in_helper(obj1);
45225 if (arg2 == NULL) SWIG_fail;
45226 temp2 = true;
45227 }
45228 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45229 if (!SWIG_IsOK(ecode3)) {
45230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45231 }
45232 arg3 = static_cast< unsigned int >(val3);
45233 if (obj3) {
45234 arg4 = obj3;
45235 }
45236 {
45237 PyThreadState* __tstate = wxPyBeginAllowThreads();
45238 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45239 wxPyEndAllowThreads(__tstate);
45240 if (PyErr_Occurred()) SWIG_fail;
45241 }
45242 resultobj = SWIG_From_int(static_cast< int >(result));
45243 {
45244 if (temp2)
45245 delete arg2;
45246 }
45247 return resultobj;
45248 fail:
45249 {
45250 if (temp2)
45251 delete arg2;
45252 }
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45258 PyObject *resultobj = 0;
45259 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45260 void *argp1 = 0 ;
45261 int res1 = 0 ;
45262 PyObject *swig_obj[1] ;
45263
45264 if (!args) SWIG_fail;
45265 swig_obj[0] = args;
45266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45267 if (!SWIG_IsOK(res1)) {
45268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45269 }
45270 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45271 {
45272 PyThreadState* __tstate = wxPyBeginAllowThreads();
45273 (arg1)->Clear();
45274 wxPyEndAllowThreads(__tstate);
45275 if (PyErr_Occurred()) SWIG_fail;
45276 }
45277 resultobj = SWIG_Py_Void();
45278 return resultobj;
45279 fail:
45280 return NULL;
45281 }
45282
45283
45284 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45285 PyObject *resultobj = 0;
45286 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45287 unsigned int arg2 ;
45288 void *argp1 = 0 ;
45289 int res1 = 0 ;
45290 unsigned int val2 ;
45291 int ecode2 = 0 ;
45292 PyObject * obj0 = 0 ;
45293 PyObject * obj1 = 0 ;
45294 char * kwnames[] = {
45295 (char *) "self",(char *) "n", NULL
45296 };
45297
45298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45300 if (!SWIG_IsOK(res1)) {
45301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45302 }
45303 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45304 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45305 if (!SWIG_IsOK(ecode2)) {
45306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45307 }
45308 arg2 = static_cast< unsigned int >(val2);
45309 {
45310 PyThreadState* __tstate = wxPyBeginAllowThreads();
45311 (arg1)->Delete(arg2);
45312 wxPyEndAllowThreads(__tstate);
45313 if (PyErr_Occurred()) SWIG_fail;
45314 }
45315 resultobj = SWIG_Py_Void();
45316 return resultobj;
45317 fail:
45318 return NULL;
45319 }
45320
45321
45322 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45323 PyObject *resultobj = 0;
45324 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45325 unsigned int arg2 ;
45326 PyObject *result = 0 ;
45327 void *argp1 = 0 ;
45328 int res1 = 0 ;
45329 unsigned int val2 ;
45330 int ecode2 = 0 ;
45331 PyObject * obj0 = 0 ;
45332 PyObject * obj1 = 0 ;
45333 char * kwnames[] = {
45334 (char *) "self",(char *) "n", NULL
45335 };
45336
45337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45339 if (!SWIG_IsOK(res1)) {
45340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45341 }
45342 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45343 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45344 if (!SWIG_IsOK(ecode2)) {
45345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45346 }
45347 arg2 = static_cast< unsigned int >(val2);
45348 {
45349 PyThreadState* __tstate = wxPyBeginAllowThreads();
45350 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45351 wxPyEndAllowThreads(__tstate);
45352 if (PyErr_Occurred()) SWIG_fail;
45353 }
45354 resultobj = result;
45355 return resultobj;
45356 fail:
45357 return NULL;
45358 }
45359
45360
45361 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45362 PyObject *resultobj = 0;
45363 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45364 unsigned int arg2 ;
45365 PyObject *arg3 = (PyObject *) 0 ;
45366 void *argp1 = 0 ;
45367 int res1 = 0 ;
45368 unsigned int val2 ;
45369 int ecode2 = 0 ;
45370 PyObject * obj0 = 0 ;
45371 PyObject * obj1 = 0 ;
45372 PyObject * obj2 = 0 ;
45373 char * kwnames[] = {
45374 (char *) "self",(char *) "n",(char *) "clientData", NULL
45375 };
45376
45377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45379 if (!SWIG_IsOK(res1)) {
45380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45381 }
45382 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45383 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45384 if (!SWIG_IsOK(ecode2)) {
45385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45386 }
45387 arg2 = static_cast< unsigned int >(val2);
45388 arg3 = obj2;
45389 {
45390 PyThreadState* __tstate = wxPyBeginAllowThreads();
45391 wxItemContainer_SetClientData(arg1,arg2,arg3);
45392 wxPyEndAllowThreads(__tstate);
45393 if (PyErr_Occurred()) SWIG_fail;
45394 }
45395 resultobj = SWIG_Py_Void();
45396 return resultobj;
45397 fail:
45398 return NULL;
45399 }
45400
45401
45402 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45403 PyObject *resultobj = 0;
45404 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45405 unsigned int result;
45406 void *argp1 = 0 ;
45407 int res1 = 0 ;
45408 PyObject *swig_obj[1] ;
45409
45410 if (!args) SWIG_fail;
45411 swig_obj[0] = args;
45412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45413 if (!SWIG_IsOK(res1)) {
45414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45415 }
45416 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45417 {
45418 PyThreadState* __tstate = wxPyBeginAllowThreads();
45419 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45420 wxPyEndAllowThreads(__tstate);
45421 if (PyErr_Occurred()) SWIG_fail;
45422 }
45423 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45424 return resultobj;
45425 fail:
45426 return NULL;
45427 }
45428
45429
45430 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45431 PyObject *resultobj = 0;
45432 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45433 bool result;
45434 void *argp1 = 0 ;
45435 int res1 = 0 ;
45436 PyObject *swig_obj[1] ;
45437
45438 if (!args) SWIG_fail;
45439 swig_obj[0] = args;
45440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45441 if (!SWIG_IsOK(res1)) {
45442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45443 }
45444 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45445 {
45446 PyThreadState* __tstate = wxPyBeginAllowThreads();
45447 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45448 wxPyEndAllowThreads(__tstate);
45449 if (PyErr_Occurred()) SWIG_fail;
45450 }
45451 {
45452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45453 }
45454 return resultobj;
45455 fail:
45456 return NULL;
45457 }
45458
45459
45460 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45461 PyObject *resultobj = 0;
45462 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45463 unsigned int arg2 ;
45464 wxString result;
45465 void *argp1 = 0 ;
45466 int res1 = 0 ;
45467 unsigned int val2 ;
45468 int ecode2 = 0 ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char * kwnames[] = {
45472 (char *) "self",(char *) "n", NULL
45473 };
45474
45475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45477 if (!SWIG_IsOK(res1)) {
45478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45479 }
45480 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45481 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45482 if (!SWIG_IsOK(ecode2)) {
45483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45484 }
45485 arg2 = static_cast< unsigned int >(val2);
45486 {
45487 PyThreadState* __tstate = wxPyBeginAllowThreads();
45488 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45489 wxPyEndAllowThreads(__tstate);
45490 if (PyErr_Occurred()) SWIG_fail;
45491 }
45492 {
45493 #if wxUSE_UNICODE
45494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45495 #else
45496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45497 #endif
45498 }
45499 return resultobj;
45500 fail:
45501 return NULL;
45502 }
45503
45504
45505 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45506 PyObject *resultobj = 0;
45507 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45508 wxArrayString result;
45509 void *argp1 = 0 ;
45510 int res1 = 0 ;
45511 PyObject *swig_obj[1] ;
45512
45513 if (!args) SWIG_fail;
45514 swig_obj[0] = args;
45515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45516 if (!SWIG_IsOK(res1)) {
45517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45518 }
45519 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45520 {
45521 PyThreadState* __tstate = wxPyBeginAllowThreads();
45522 result = ((wxItemContainer const *)arg1)->GetStrings();
45523 wxPyEndAllowThreads(__tstate);
45524 if (PyErr_Occurred()) SWIG_fail;
45525 }
45526 {
45527 resultobj = wxArrayString2PyList_helper(result);
45528 }
45529 return resultobj;
45530 fail:
45531 return NULL;
45532 }
45533
45534
45535 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45536 PyObject *resultobj = 0;
45537 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45538 unsigned int arg2 ;
45539 wxString *arg3 = 0 ;
45540 void *argp1 = 0 ;
45541 int res1 = 0 ;
45542 unsigned int val2 ;
45543 int ecode2 = 0 ;
45544 bool temp3 = false ;
45545 PyObject * obj0 = 0 ;
45546 PyObject * obj1 = 0 ;
45547 PyObject * obj2 = 0 ;
45548 char * kwnames[] = {
45549 (char *) "self",(char *) "n",(char *) "s", NULL
45550 };
45551
45552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45554 if (!SWIG_IsOK(res1)) {
45555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45556 }
45557 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45558 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45559 if (!SWIG_IsOK(ecode2)) {
45560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45561 }
45562 arg2 = static_cast< unsigned int >(val2);
45563 {
45564 arg3 = wxString_in_helper(obj2);
45565 if (arg3 == NULL) SWIG_fail;
45566 temp3 = true;
45567 }
45568 {
45569 PyThreadState* __tstate = wxPyBeginAllowThreads();
45570 (arg1)->SetString(arg2,(wxString const &)*arg3);
45571 wxPyEndAllowThreads(__tstate);
45572 if (PyErr_Occurred()) SWIG_fail;
45573 }
45574 resultobj = SWIG_Py_Void();
45575 {
45576 if (temp3)
45577 delete arg3;
45578 }
45579 return resultobj;
45580 fail:
45581 {
45582 if (temp3)
45583 delete arg3;
45584 }
45585 return NULL;
45586 }
45587
45588
45589 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45590 PyObject *resultobj = 0;
45591 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45592 wxString *arg2 = 0 ;
45593 int result;
45594 void *argp1 = 0 ;
45595 int res1 = 0 ;
45596 bool temp2 = false ;
45597 PyObject * obj0 = 0 ;
45598 PyObject * obj1 = 0 ;
45599 char * kwnames[] = {
45600 (char *) "self",(char *) "s", NULL
45601 };
45602
45603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45605 if (!SWIG_IsOK(res1)) {
45606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45607 }
45608 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45609 {
45610 arg2 = wxString_in_helper(obj1);
45611 if (arg2 == NULL) SWIG_fail;
45612 temp2 = true;
45613 }
45614 {
45615 PyThreadState* __tstate = wxPyBeginAllowThreads();
45616 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45617 wxPyEndAllowThreads(__tstate);
45618 if (PyErr_Occurred()) SWIG_fail;
45619 }
45620 resultobj = SWIG_From_int(static_cast< int >(result));
45621 {
45622 if (temp2)
45623 delete arg2;
45624 }
45625 return resultobj;
45626 fail:
45627 {
45628 if (temp2)
45629 delete arg2;
45630 }
45631 return NULL;
45632 }
45633
45634
45635 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45636 PyObject *resultobj = 0;
45637 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45638 int arg2 ;
45639 void *argp1 = 0 ;
45640 int res1 = 0 ;
45641 int val2 ;
45642 int ecode2 = 0 ;
45643 PyObject * obj0 = 0 ;
45644 PyObject * obj1 = 0 ;
45645 char * kwnames[] = {
45646 (char *) "self",(char *) "n", NULL
45647 };
45648
45649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45651 if (!SWIG_IsOK(res1)) {
45652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45653 }
45654 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45655 ecode2 = SWIG_AsVal_int(obj1, &val2);
45656 if (!SWIG_IsOK(ecode2)) {
45657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45658 }
45659 arg2 = static_cast< int >(val2);
45660 {
45661 PyThreadState* __tstate = wxPyBeginAllowThreads();
45662 (arg1)->SetSelection(arg2);
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_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45674 PyObject *resultobj = 0;
45675 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45676 int 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_wxItemContainer, 0 | 0 );
45684 if (!SWIG_IsOK(res1)) {
45685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45686 }
45687 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45688 {
45689 PyThreadState* __tstate = wxPyBeginAllowThreads();
45690 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45691 wxPyEndAllowThreads(__tstate);
45692 if (PyErr_Occurred()) SWIG_fail;
45693 }
45694 resultobj = SWIG_From_int(static_cast< int >(result));
45695 return resultobj;
45696 fail:
45697 return NULL;
45698 }
45699
45700
45701 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45702 PyObject *resultobj = 0;
45703 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45704 wxString *arg2 = 0 ;
45705 bool result;
45706 void *argp1 = 0 ;
45707 int res1 = 0 ;
45708 bool temp2 = false ;
45709 PyObject * obj0 = 0 ;
45710 PyObject * obj1 = 0 ;
45711 char * kwnames[] = {
45712 (char *) "self",(char *) "s", NULL
45713 };
45714
45715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45717 if (!SWIG_IsOK(res1)) {
45718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45719 }
45720 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45721 {
45722 arg2 = wxString_in_helper(obj1);
45723 if (arg2 == NULL) SWIG_fail;
45724 temp2 = true;
45725 }
45726 {
45727 PyThreadState* __tstate = wxPyBeginAllowThreads();
45728 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45729 wxPyEndAllowThreads(__tstate);
45730 if (PyErr_Occurred()) SWIG_fail;
45731 }
45732 {
45733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45734 }
45735 {
45736 if (temp2)
45737 delete arg2;
45738 }
45739 return resultobj;
45740 fail:
45741 {
45742 if (temp2)
45743 delete arg2;
45744 }
45745 return NULL;
45746 }
45747
45748
45749 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45750 PyObject *resultobj = 0;
45751 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45752 wxString result;
45753 void *argp1 = 0 ;
45754 int res1 = 0 ;
45755 PyObject *swig_obj[1] ;
45756
45757 if (!args) SWIG_fail;
45758 swig_obj[0] = args;
45759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45760 if (!SWIG_IsOK(res1)) {
45761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45762 }
45763 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45764 {
45765 PyThreadState* __tstate = wxPyBeginAllowThreads();
45766 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45767 wxPyEndAllowThreads(__tstate);
45768 if (PyErr_Occurred()) SWIG_fail;
45769 }
45770 {
45771 #if wxUSE_UNICODE
45772 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45773 #else
45774 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45775 #endif
45776 }
45777 return resultobj;
45778 fail:
45779 return NULL;
45780 }
45781
45782
45783 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45784 PyObject *resultobj = 0;
45785 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45786 int arg2 ;
45787 void *argp1 = 0 ;
45788 int res1 = 0 ;
45789 int val2 ;
45790 int ecode2 = 0 ;
45791 PyObject * obj0 = 0 ;
45792 PyObject * obj1 = 0 ;
45793 char * kwnames[] = {
45794 (char *) "self",(char *) "n", NULL
45795 };
45796
45797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45799 if (!SWIG_IsOK(res1)) {
45800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45801 }
45802 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45803 ecode2 = SWIG_AsVal_int(obj1, &val2);
45804 if (!SWIG_IsOK(ecode2)) {
45805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45806 }
45807 arg2 = static_cast< int >(val2);
45808 {
45809 PyThreadState* __tstate = wxPyBeginAllowThreads();
45810 (arg1)->Select(arg2);
45811 wxPyEndAllowThreads(__tstate);
45812 if (PyErr_Occurred()) SWIG_fail;
45813 }
45814 resultobj = SWIG_Py_Void();
45815 return resultobj;
45816 fail:
45817 return NULL;
45818 }
45819
45820
45821 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45822 PyObject *obj;
45823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45824 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45825 return SWIG_Py_Void();
45826 }
45827
45828 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45829 PyObject *obj;
45830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45831 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45832 return SWIG_Py_Void();
45833 }
45834
45835 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45836 PyObject *resultobj = 0;
45837 wxSizerItem *result = 0 ;
45838
45839 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45840 {
45841 PyThreadState* __tstate = wxPyBeginAllowThreads();
45842 result = (wxSizerItem *)new wxSizerItem();
45843 wxPyEndAllowThreads(__tstate);
45844 if (PyErr_Occurred()) SWIG_fail;
45845 }
45846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45847 return resultobj;
45848 fail:
45849 return NULL;
45850 }
45851
45852
45853 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45854 PyObject *resultobj = 0;
45855 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45856 void *argp1 = 0 ;
45857 int res1 = 0 ;
45858 PyObject *swig_obj[1] ;
45859
45860 if (!args) SWIG_fail;
45861 swig_obj[0] = args;
45862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45865 }
45866 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45867 {
45868 PyThreadState* __tstate = wxPyBeginAllowThreads();
45869 delete arg1;
45870
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 resultobj = SWIG_Py_Void();
45875 return resultobj;
45876 fail:
45877 return NULL;
45878 }
45879
45880
45881 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45882 PyObject *resultobj = 0;
45883 wxWindow *arg1 = (wxWindow *) 0 ;
45884 int arg2 ;
45885 int arg3 ;
45886 int arg4 ;
45887 PyObject *arg5 = (PyObject *) NULL ;
45888 wxSizerItem *result = 0 ;
45889 void *argp1 = 0 ;
45890 int res1 = 0 ;
45891 int val2 ;
45892 int ecode2 = 0 ;
45893 int val3 ;
45894 int ecode3 = 0 ;
45895 int val4 ;
45896 int ecode4 = 0 ;
45897 PyObject * obj0 = 0 ;
45898 PyObject * obj1 = 0 ;
45899 PyObject * obj2 = 0 ;
45900 PyObject * obj3 = 0 ;
45901 PyObject * obj4 = 0 ;
45902 char * kwnames[] = {
45903 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45904 };
45905
45906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45908 if (!SWIG_IsOK(res1)) {
45909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45910 }
45911 arg1 = reinterpret_cast< wxWindow * >(argp1);
45912 ecode2 = SWIG_AsVal_int(obj1, &val2);
45913 if (!SWIG_IsOK(ecode2)) {
45914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45915 }
45916 arg2 = static_cast< int >(val2);
45917 ecode3 = SWIG_AsVal_int(obj2, &val3);
45918 if (!SWIG_IsOK(ecode3)) {
45919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45920 }
45921 arg3 = static_cast< int >(val3);
45922 ecode4 = SWIG_AsVal_int(obj3, &val4);
45923 if (!SWIG_IsOK(ecode4)) {
45924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45925 }
45926 arg4 = static_cast< int >(val4);
45927 if (obj4) {
45928 arg5 = obj4;
45929 }
45930 {
45931 PyThreadState* __tstate = wxPyBeginAllowThreads();
45932 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45933 wxPyEndAllowThreads(__tstate);
45934 if (PyErr_Occurred()) SWIG_fail;
45935 }
45936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45937 return resultobj;
45938 fail:
45939 return NULL;
45940 }
45941
45942
45943 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45944 PyObject *resultobj = 0;
45945 int arg1 ;
45946 int arg2 ;
45947 int arg3 ;
45948 int arg4 ;
45949 int arg5 ;
45950 PyObject *arg6 = (PyObject *) NULL ;
45951 wxSizerItem *result = 0 ;
45952 int val1 ;
45953 int ecode1 = 0 ;
45954 int val2 ;
45955 int ecode2 = 0 ;
45956 int val3 ;
45957 int ecode3 = 0 ;
45958 int val4 ;
45959 int ecode4 = 0 ;
45960 int val5 ;
45961 int ecode5 = 0 ;
45962 PyObject * obj0 = 0 ;
45963 PyObject * obj1 = 0 ;
45964 PyObject * obj2 = 0 ;
45965 PyObject * obj3 = 0 ;
45966 PyObject * obj4 = 0 ;
45967 PyObject * obj5 = 0 ;
45968 char * kwnames[] = {
45969 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45970 };
45971
45972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45973 ecode1 = SWIG_AsVal_int(obj0, &val1);
45974 if (!SWIG_IsOK(ecode1)) {
45975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45976 }
45977 arg1 = static_cast< int >(val1);
45978 ecode2 = SWIG_AsVal_int(obj1, &val2);
45979 if (!SWIG_IsOK(ecode2)) {
45980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45981 }
45982 arg2 = static_cast< int >(val2);
45983 ecode3 = SWIG_AsVal_int(obj2, &val3);
45984 if (!SWIG_IsOK(ecode3)) {
45985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45986 }
45987 arg3 = static_cast< int >(val3);
45988 ecode4 = SWIG_AsVal_int(obj3, &val4);
45989 if (!SWIG_IsOK(ecode4)) {
45990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45991 }
45992 arg4 = static_cast< int >(val4);
45993 ecode5 = SWIG_AsVal_int(obj4, &val5);
45994 if (!SWIG_IsOK(ecode5)) {
45995 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45996 }
45997 arg5 = static_cast< int >(val5);
45998 if (obj5) {
45999 arg6 = obj5;
46000 }
46001 {
46002 PyThreadState* __tstate = wxPyBeginAllowThreads();
46003 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46004 wxPyEndAllowThreads(__tstate);
46005 if (PyErr_Occurred()) SWIG_fail;
46006 }
46007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46008 return resultobj;
46009 fail:
46010 return NULL;
46011 }
46012
46013
46014 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46015 PyObject *resultobj = 0;
46016 wxSizer *arg1 = (wxSizer *) 0 ;
46017 int arg2 ;
46018 int arg3 ;
46019 int arg4 ;
46020 PyObject *arg5 = (PyObject *) NULL ;
46021 wxSizerItem *result = 0 ;
46022 int res1 = 0 ;
46023 int val2 ;
46024 int ecode2 = 0 ;
46025 int val3 ;
46026 int ecode3 = 0 ;
46027 int val4 ;
46028 int ecode4 = 0 ;
46029 PyObject * obj0 = 0 ;
46030 PyObject * obj1 = 0 ;
46031 PyObject * obj2 = 0 ;
46032 PyObject * obj3 = 0 ;
46033 PyObject * obj4 = 0 ;
46034 char * kwnames[] = {
46035 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46036 };
46037
46038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46039 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46040 if (!SWIG_IsOK(res1)) {
46041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46042 }
46043 ecode2 = SWIG_AsVal_int(obj1, &val2);
46044 if (!SWIG_IsOK(ecode2)) {
46045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46046 }
46047 arg2 = static_cast< int >(val2);
46048 ecode3 = SWIG_AsVal_int(obj2, &val3);
46049 if (!SWIG_IsOK(ecode3)) {
46050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46051 }
46052 arg3 = static_cast< int >(val3);
46053 ecode4 = SWIG_AsVal_int(obj3, &val4);
46054 if (!SWIG_IsOK(ecode4)) {
46055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46056 }
46057 arg4 = static_cast< int >(val4);
46058 if (obj4) {
46059 arg5 = obj4;
46060 }
46061 {
46062 PyThreadState* __tstate = wxPyBeginAllowThreads();
46063 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46064 wxPyEndAllowThreads(__tstate);
46065 if (PyErr_Occurred()) SWIG_fail;
46066 }
46067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46068 return resultobj;
46069 fail:
46070 return NULL;
46071 }
46072
46073
46074 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46075 PyObject *resultobj = 0;
46076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46077 void *argp1 = 0 ;
46078 int res1 = 0 ;
46079 PyObject *swig_obj[1] ;
46080
46081 if (!args) SWIG_fail;
46082 swig_obj[0] = args;
46083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46084 if (!SWIG_IsOK(res1)) {
46085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46086 }
46087 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46088 {
46089 PyThreadState* __tstate = wxPyBeginAllowThreads();
46090 (arg1)->DeleteWindows();
46091 wxPyEndAllowThreads(__tstate);
46092 if (PyErr_Occurred()) SWIG_fail;
46093 }
46094 resultobj = SWIG_Py_Void();
46095 return resultobj;
46096 fail:
46097 return NULL;
46098 }
46099
46100
46101 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46102 PyObject *resultobj = 0;
46103 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46104 void *argp1 = 0 ;
46105 int res1 = 0 ;
46106 PyObject *swig_obj[1] ;
46107
46108 if (!args) SWIG_fail;
46109 swig_obj[0] = args;
46110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46111 if (!SWIG_IsOK(res1)) {
46112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46113 }
46114 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46115 {
46116 PyThreadState* __tstate = wxPyBeginAllowThreads();
46117 (arg1)->DetachSizer();
46118 wxPyEndAllowThreads(__tstate);
46119 if (PyErr_Occurred()) SWIG_fail;
46120 }
46121 resultobj = SWIG_Py_Void();
46122 return resultobj;
46123 fail:
46124 return NULL;
46125 }
46126
46127
46128 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46129 PyObject *resultobj = 0;
46130 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46131 wxSize result;
46132 void *argp1 = 0 ;
46133 int res1 = 0 ;
46134 PyObject *swig_obj[1] ;
46135
46136 if (!args) SWIG_fail;
46137 swig_obj[0] = args;
46138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46139 if (!SWIG_IsOK(res1)) {
46140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46141 }
46142 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46143 {
46144 PyThreadState* __tstate = wxPyBeginAllowThreads();
46145 result = (arg1)->GetSize();
46146 wxPyEndAllowThreads(__tstate);
46147 if (PyErr_Occurred()) SWIG_fail;
46148 }
46149 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46150 return resultobj;
46151 fail:
46152 return NULL;
46153 }
46154
46155
46156 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46157 PyObject *resultobj = 0;
46158 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46159 wxSize result;
46160 void *argp1 = 0 ;
46161 int res1 = 0 ;
46162 PyObject *swig_obj[1] ;
46163
46164 if (!args) SWIG_fail;
46165 swig_obj[0] = args;
46166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46167 if (!SWIG_IsOK(res1)) {
46168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46169 }
46170 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46171 {
46172 PyThreadState* __tstate = wxPyBeginAllowThreads();
46173 result = (arg1)->CalcMin();
46174 wxPyEndAllowThreads(__tstate);
46175 if (PyErr_Occurred()) SWIG_fail;
46176 }
46177 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46178 return resultobj;
46179 fail:
46180 return NULL;
46181 }
46182
46183
46184 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46185 PyObject *resultobj = 0;
46186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46187 wxPoint *arg2 = 0 ;
46188 wxSize *arg3 = 0 ;
46189 void *argp1 = 0 ;
46190 int res1 = 0 ;
46191 wxPoint temp2 ;
46192 wxSize temp3 ;
46193 PyObject * obj0 = 0 ;
46194 PyObject * obj1 = 0 ;
46195 PyObject * obj2 = 0 ;
46196 char * kwnames[] = {
46197 (char *) "self",(char *) "pos",(char *) "size", NULL
46198 };
46199
46200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46202 if (!SWIG_IsOK(res1)) {
46203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46204 }
46205 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46206 {
46207 arg2 = &temp2;
46208 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46209 }
46210 {
46211 arg3 = &temp3;
46212 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46213 }
46214 {
46215 PyThreadState* __tstate = wxPyBeginAllowThreads();
46216 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46217 wxPyEndAllowThreads(__tstate);
46218 if (PyErr_Occurred()) SWIG_fail;
46219 }
46220 resultobj = SWIG_Py_Void();
46221 return resultobj;
46222 fail:
46223 return NULL;
46224 }
46225
46226
46227 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46228 PyObject *resultobj = 0;
46229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46230 wxSize result;
46231 void *argp1 = 0 ;
46232 int res1 = 0 ;
46233 PyObject *swig_obj[1] ;
46234
46235 if (!args) SWIG_fail;
46236 swig_obj[0] = args;
46237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46238 if (!SWIG_IsOK(res1)) {
46239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46240 }
46241 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46242 {
46243 PyThreadState* __tstate = wxPyBeginAllowThreads();
46244 result = (arg1)->GetMinSize();
46245 wxPyEndAllowThreads(__tstate);
46246 if (PyErr_Occurred()) SWIG_fail;
46247 }
46248 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46249 return resultobj;
46250 fail:
46251 return NULL;
46252 }
46253
46254
46255 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46256 PyObject *resultobj = 0;
46257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46258 wxSize result;
46259 void *argp1 = 0 ;
46260 int res1 = 0 ;
46261 PyObject *swig_obj[1] ;
46262
46263 if (!args) SWIG_fail;
46264 swig_obj[0] = args;
46265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46266 if (!SWIG_IsOK(res1)) {
46267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46268 }
46269 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46277 return resultobj;
46278 fail:
46279 return NULL;
46280 }
46281
46282
46283 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46284 PyObject *resultobj = 0;
46285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46286 int arg2 ;
46287 int arg3 ;
46288 void *argp1 = 0 ;
46289 int res1 = 0 ;
46290 int val2 ;
46291 int ecode2 = 0 ;
46292 int val3 ;
46293 int ecode3 = 0 ;
46294 PyObject * obj0 = 0 ;
46295 PyObject * obj1 = 0 ;
46296 PyObject * obj2 = 0 ;
46297 char * kwnames[] = {
46298 (char *) "self",(char *) "x",(char *) "y", NULL
46299 };
46300
46301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46303 if (!SWIG_IsOK(res1)) {
46304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46305 }
46306 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46307 ecode2 = SWIG_AsVal_int(obj1, &val2);
46308 if (!SWIG_IsOK(ecode2)) {
46309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46310 }
46311 arg2 = static_cast< int >(val2);
46312 ecode3 = SWIG_AsVal_int(obj2, &val3);
46313 if (!SWIG_IsOK(ecode3)) {
46314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46315 }
46316 arg3 = static_cast< int >(val3);
46317 {
46318 PyThreadState* __tstate = wxPyBeginAllowThreads();
46319 (arg1)->SetInitSize(arg2,arg3);
46320 wxPyEndAllowThreads(__tstate);
46321 if (PyErr_Occurred()) SWIG_fail;
46322 }
46323 resultobj = SWIG_Py_Void();
46324 return resultobj;
46325 fail:
46326 return NULL;
46327 }
46328
46329
46330 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46331 PyObject *resultobj = 0;
46332 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46333 int arg2 ;
46334 int arg3 ;
46335 void *argp1 = 0 ;
46336 int res1 = 0 ;
46337 int val2 ;
46338 int ecode2 = 0 ;
46339 int val3 ;
46340 int ecode3 = 0 ;
46341 PyObject * obj0 = 0 ;
46342 PyObject * obj1 = 0 ;
46343 PyObject * obj2 = 0 ;
46344 char * kwnames[] = {
46345 (char *) "self",(char *) "width",(char *) "height", NULL
46346 };
46347
46348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46350 if (!SWIG_IsOK(res1)) {
46351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46352 }
46353 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46354 ecode2 = SWIG_AsVal_int(obj1, &val2);
46355 if (!SWIG_IsOK(ecode2)) {
46356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46357 }
46358 arg2 = static_cast< int >(val2);
46359 ecode3 = SWIG_AsVal_int(obj2, &val3);
46360 if (!SWIG_IsOK(ecode3)) {
46361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46362 }
46363 arg3 = static_cast< int >(val3);
46364 {
46365 PyThreadState* __tstate = wxPyBeginAllowThreads();
46366 (arg1)->SetRatio(arg2,arg3);
46367 wxPyEndAllowThreads(__tstate);
46368 if (PyErr_Occurred()) SWIG_fail;
46369 }
46370 resultobj = SWIG_Py_Void();
46371 return resultobj;
46372 fail:
46373 return NULL;
46374 }
46375
46376
46377 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46378 PyObject *resultobj = 0;
46379 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46380 wxSize *arg2 = 0 ;
46381 void *argp1 = 0 ;
46382 int res1 = 0 ;
46383 wxSize temp2 ;
46384 PyObject * obj0 = 0 ;
46385 PyObject * obj1 = 0 ;
46386 char * kwnames[] = {
46387 (char *) "self",(char *) "size", NULL
46388 };
46389
46390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46392 if (!SWIG_IsOK(res1)) {
46393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46394 }
46395 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46396 {
46397 arg2 = &temp2;
46398 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46399 }
46400 {
46401 PyThreadState* __tstate = wxPyBeginAllowThreads();
46402 (arg1)->SetRatio((wxSize const &)*arg2);
46403 wxPyEndAllowThreads(__tstate);
46404 if (PyErr_Occurred()) SWIG_fail;
46405 }
46406 resultobj = SWIG_Py_Void();
46407 return resultobj;
46408 fail:
46409 return NULL;
46410 }
46411
46412
46413 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46414 PyObject *resultobj = 0;
46415 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46416 float arg2 ;
46417 void *argp1 = 0 ;
46418 int res1 = 0 ;
46419 float val2 ;
46420 int ecode2 = 0 ;
46421 PyObject * obj0 = 0 ;
46422 PyObject * obj1 = 0 ;
46423 char * kwnames[] = {
46424 (char *) "self",(char *) "ratio", NULL
46425 };
46426
46427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46429 if (!SWIG_IsOK(res1)) {
46430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46431 }
46432 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46433 ecode2 = SWIG_AsVal_float(obj1, &val2);
46434 if (!SWIG_IsOK(ecode2)) {
46435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46436 }
46437 arg2 = static_cast< float >(val2);
46438 {
46439 PyThreadState* __tstate = wxPyBeginAllowThreads();
46440 (arg1)->SetRatio(arg2);
46441 wxPyEndAllowThreads(__tstate);
46442 if (PyErr_Occurred()) SWIG_fail;
46443 }
46444 resultobj = SWIG_Py_Void();
46445 return resultobj;
46446 fail:
46447 return NULL;
46448 }
46449
46450
46451 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46452 PyObject *resultobj = 0;
46453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46454 float result;
46455 void *argp1 = 0 ;
46456 int res1 = 0 ;
46457 PyObject *swig_obj[1] ;
46458
46459 if (!args) SWIG_fail;
46460 swig_obj[0] = args;
46461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46462 if (!SWIG_IsOK(res1)) {
46463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46464 }
46465 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46466 {
46467 PyThreadState* __tstate = wxPyBeginAllowThreads();
46468 result = (float)(arg1)->GetRatio();
46469 wxPyEndAllowThreads(__tstate);
46470 if (PyErr_Occurred()) SWIG_fail;
46471 }
46472 resultobj = SWIG_From_float(static_cast< float >(result));
46473 return resultobj;
46474 fail:
46475 return NULL;
46476 }
46477
46478
46479 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46480 PyObject *resultobj = 0;
46481 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46482 wxRect result;
46483 void *argp1 = 0 ;
46484 int res1 = 0 ;
46485 PyObject *swig_obj[1] ;
46486
46487 if (!args) SWIG_fail;
46488 swig_obj[0] = args;
46489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46490 if (!SWIG_IsOK(res1)) {
46491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46492 }
46493 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46494 {
46495 PyThreadState* __tstate = wxPyBeginAllowThreads();
46496 result = (arg1)->GetRect();
46497 wxPyEndAllowThreads(__tstate);
46498 if (PyErr_Occurred()) SWIG_fail;
46499 }
46500 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46501 return resultobj;
46502 fail:
46503 return NULL;
46504 }
46505
46506
46507 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46508 PyObject *resultobj = 0;
46509 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46510 bool result;
46511 void *argp1 = 0 ;
46512 int res1 = 0 ;
46513 PyObject *swig_obj[1] ;
46514
46515 if (!args) SWIG_fail;
46516 swig_obj[0] = args;
46517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46520 }
46521 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 result = (bool)(arg1)->IsWindow();
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 {
46529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46530 }
46531 return resultobj;
46532 fail:
46533 return NULL;
46534 }
46535
46536
46537 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46538 PyObject *resultobj = 0;
46539 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46540 bool result;
46541 void *argp1 = 0 ;
46542 int res1 = 0 ;
46543 PyObject *swig_obj[1] ;
46544
46545 if (!args) SWIG_fail;
46546 swig_obj[0] = args;
46547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46548 if (!SWIG_IsOK(res1)) {
46549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46550 }
46551 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46552 {
46553 PyThreadState* __tstate = wxPyBeginAllowThreads();
46554 result = (bool)(arg1)->IsSizer();
46555 wxPyEndAllowThreads(__tstate);
46556 if (PyErr_Occurred()) SWIG_fail;
46557 }
46558 {
46559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46560 }
46561 return resultobj;
46562 fail:
46563 return NULL;
46564 }
46565
46566
46567 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46568 PyObject *resultobj = 0;
46569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46570 bool result;
46571 void *argp1 = 0 ;
46572 int res1 = 0 ;
46573 PyObject *swig_obj[1] ;
46574
46575 if (!args) SWIG_fail;
46576 swig_obj[0] = args;
46577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46578 if (!SWIG_IsOK(res1)) {
46579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46580 }
46581 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46582 {
46583 PyThreadState* __tstate = wxPyBeginAllowThreads();
46584 result = (bool)(arg1)->IsSpacer();
46585 wxPyEndAllowThreads(__tstate);
46586 if (PyErr_Occurred()) SWIG_fail;
46587 }
46588 {
46589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46590 }
46591 return resultobj;
46592 fail:
46593 return NULL;
46594 }
46595
46596
46597 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46598 PyObject *resultobj = 0;
46599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46600 int arg2 ;
46601 void *argp1 = 0 ;
46602 int res1 = 0 ;
46603 int val2 ;
46604 int ecode2 = 0 ;
46605 PyObject * obj0 = 0 ;
46606 PyObject * obj1 = 0 ;
46607 char * kwnames[] = {
46608 (char *) "self",(char *) "proportion", NULL
46609 };
46610
46611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46613 if (!SWIG_IsOK(res1)) {
46614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46615 }
46616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46617 ecode2 = SWIG_AsVal_int(obj1, &val2);
46618 if (!SWIG_IsOK(ecode2)) {
46619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46620 }
46621 arg2 = static_cast< int >(val2);
46622 {
46623 PyThreadState* __tstate = wxPyBeginAllowThreads();
46624 (arg1)->SetProportion(arg2);
46625 wxPyEndAllowThreads(__tstate);
46626 if (PyErr_Occurred()) SWIG_fail;
46627 }
46628 resultobj = SWIG_Py_Void();
46629 return resultobj;
46630 fail:
46631 return NULL;
46632 }
46633
46634
46635 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46636 PyObject *resultobj = 0;
46637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46638 int result;
46639 void *argp1 = 0 ;
46640 int res1 = 0 ;
46641 PyObject *swig_obj[1] ;
46642
46643 if (!args) SWIG_fail;
46644 swig_obj[0] = args;
46645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46646 if (!SWIG_IsOK(res1)) {
46647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46648 }
46649 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46650 {
46651 PyThreadState* __tstate = wxPyBeginAllowThreads();
46652 result = (int)(arg1)->GetProportion();
46653 wxPyEndAllowThreads(__tstate);
46654 if (PyErr_Occurred()) SWIG_fail;
46655 }
46656 resultobj = SWIG_From_int(static_cast< int >(result));
46657 return resultobj;
46658 fail:
46659 return NULL;
46660 }
46661
46662
46663 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46664 PyObject *resultobj = 0;
46665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46666 int arg2 ;
46667 void *argp1 = 0 ;
46668 int res1 = 0 ;
46669 int val2 ;
46670 int ecode2 = 0 ;
46671 PyObject * obj0 = 0 ;
46672 PyObject * obj1 = 0 ;
46673 char * kwnames[] = {
46674 (char *) "self",(char *) "flag", NULL
46675 };
46676
46677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46679 if (!SWIG_IsOK(res1)) {
46680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46681 }
46682 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46683 ecode2 = SWIG_AsVal_int(obj1, &val2);
46684 if (!SWIG_IsOK(ecode2)) {
46685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46686 }
46687 arg2 = static_cast< int >(val2);
46688 {
46689 PyThreadState* __tstate = wxPyBeginAllowThreads();
46690 (arg1)->SetFlag(arg2);
46691 wxPyEndAllowThreads(__tstate);
46692 if (PyErr_Occurred()) SWIG_fail;
46693 }
46694 resultobj = SWIG_Py_Void();
46695 return resultobj;
46696 fail:
46697 return NULL;
46698 }
46699
46700
46701 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46702 PyObject *resultobj = 0;
46703 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46704 int result;
46705 void *argp1 = 0 ;
46706 int res1 = 0 ;
46707 PyObject *swig_obj[1] ;
46708
46709 if (!args) SWIG_fail;
46710 swig_obj[0] = args;
46711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46712 if (!SWIG_IsOK(res1)) {
46713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46714 }
46715 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46716 {
46717 PyThreadState* __tstate = wxPyBeginAllowThreads();
46718 result = (int)(arg1)->GetFlag();
46719 wxPyEndAllowThreads(__tstate);
46720 if (PyErr_Occurred()) SWIG_fail;
46721 }
46722 resultobj = SWIG_From_int(static_cast< int >(result));
46723 return resultobj;
46724 fail:
46725 return NULL;
46726 }
46727
46728
46729 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46730 PyObject *resultobj = 0;
46731 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46732 int arg2 ;
46733 void *argp1 = 0 ;
46734 int res1 = 0 ;
46735 int val2 ;
46736 int ecode2 = 0 ;
46737 PyObject * obj0 = 0 ;
46738 PyObject * obj1 = 0 ;
46739 char * kwnames[] = {
46740 (char *) "self",(char *) "border", NULL
46741 };
46742
46743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46745 if (!SWIG_IsOK(res1)) {
46746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46747 }
46748 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46749 ecode2 = SWIG_AsVal_int(obj1, &val2);
46750 if (!SWIG_IsOK(ecode2)) {
46751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46752 }
46753 arg2 = static_cast< int >(val2);
46754 {
46755 PyThreadState* __tstate = wxPyBeginAllowThreads();
46756 (arg1)->SetBorder(arg2);
46757 wxPyEndAllowThreads(__tstate);
46758 if (PyErr_Occurred()) SWIG_fail;
46759 }
46760 resultobj = SWIG_Py_Void();
46761 return resultobj;
46762 fail:
46763 return NULL;
46764 }
46765
46766
46767 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46768 PyObject *resultobj = 0;
46769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46770 int result;
46771 void *argp1 = 0 ;
46772 int res1 = 0 ;
46773 PyObject *swig_obj[1] ;
46774
46775 if (!args) SWIG_fail;
46776 swig_obj[0] = args;
46777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46778 if (!SWIG_IsOK(res1)) {
46779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46780 }
46781 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46782 {
46783 PyThreadState* __tstate = wxPyBeginAllowThreads();
46784 result = (int)(arg1)->GetBorder();
46785 wxPyEndAllowThreads(__tstate);
46786 if (PyErr_Occurred()) SWIG_fail;
46787 }
46788 resultobj = SWIG_From_int(static_cast< int >(result));
46789 return resultobj;
46790 fail:
46791 return NULL;
46792 }
46793
46794
46795 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46796 PyObject *resultobj = 0;
46797 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46798 wxWindow *result = 0 ;
46799 void *argp1 = 0 ;
46800 int res1 = 0 ;
46801 PyObject *swig_obj[1] ;
46802
46803 if (!args) SWIG_fail;
46804 swig_obj[0] = args;
46805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46806 if (!SWIG_IsOK(res1)) {
46807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46808 }
46809 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46810 {
46811 PyThreadState* __tstate = wxPyBeginAllowThreads();
46812 result = (wxWindow *)(arg1)->GetWindow();
46813 wxPyEndAllowThreads(__tstate);
46814 if (PyErr_Occurred()) SWIG_fail;
46815 }
46816 {
46817 resultobj = wxPyMake_wxObject(result, 0);
46818 }
46819 return resultobj;
46820 fail:
46821 return NULL;
46822 }
46823
46824
46825 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46826 PyObject *resultobj = 0;
46827 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46828 wxWindow *arg2 = (wxWindow *) 0 ;
46829 void *argp1 = 0 ;
46830 int res1 = 0 ;
46831 void *argp2 = 0 ;
46832 int res2 = 0 ;
46833 PyObject * obj0 = 0 ;
46834 PyObject * obj1 = 0 ;
46835 char * kwnames[] = {
46836 (char *) "self",(char *) "window", NULL
46837 };
46838
46839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46841 if (!SWIG_IsOK(res1)) {
46842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46843 }
46844 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46845 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46846 if (!SWIG_IsOK(res2)) {
46847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46848 }
46849 arg2 = reinterpret_cast< wxWindow * >(argp2);
46850 {
46851 PyThreadState* __tstate = wxPyBeginAllowThreads();
46852 (arg1)->SetWindow(arg2);
46853 wxPyEndAllowThreads(__tstate);
46854 if (PyErr_Occurred()) SWIG_fail;
46855 }
46856 resultobj = SWIG_Py_Void();
46857 return resultobj;
46858 fail:
46859 return NULL;
46860 }
46861
46862
46863 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46864 PyObject *resultobj = 0;
46865 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46866 wxSizer *result = 0 ;
46867 void *argp1 = 0 ;
46868 int res1 = 0 ;
46869 PyObject *swig_obj[1] ;
46870
46871 if (!args) SWIG_fail;
46872 swig_obj[0] = args;
46873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46874 if (!SWIG_IsOK(res1)) {
46875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46876 }
46877 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46878 {
46879 PyThreadState* __tstate = wxPyBeginAllowThreads();
46880 result = (wxSizer *)(arg1)->GetSizer();
46881 wxPyEndAllowThreads(__tstate);
46882 if (PyErr_Occurred()) SWIG_fail;
46883 }
46884 {
46885 resultobj = wxPyMake_wxObject(result, (bool)0);
46886 }
46887 return resultobj;
46888 fail:
46889 return NULL;
46890 }
46891
46892
46893 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46894 PyObject *resultobj = 0;
46895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46896 wxSizer *arg2 = (wxSizer *) 0 ;
46897 void *argp1 = 0 ;
46898 int res1 = 0 ;
46899 int res2 = 0 ;
46900 PyObject * obj0 = 0 ;
46901 PyObject * obj1 = 0 ;
46902 char * kwnames[] = {
46903 (char *) "self",(char *) "sizer", NULL
46904 };
46905
46906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46908 if (!SWIG_IsOK(res1)) {
46909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46910 }
46911 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46912 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46913 if (!SWIG_IsOK(res2)) {
46914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46915 }
46916 {
46917 PyThreadState* __tstate = wxPyBeginAllowThreads();
46918 (arg1)->SetSizer(arg2);
46919 wxPyEndAllowThreads(__tstate);
46920 if (PyErr_Occurred()) SWIG_fail;
46921 }
46922 resultobj = SWIG_Py_Void();
46923 return resultobj;
46924 fail:
46925 return NULL;
46926 }
46927
46928
46929 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46930 PyObject *resultobj = 0;
46931 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46932 wxSize *result = 0 ;
46933 void *argp1 = 0 ;
46934 int res1 = 0 ;
46935 PyObject *swig_obj[1] ;
46936
46937 if (!args) SWIG_fail;
46938 swig_obj[0] = args;
46939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46940 if (!SWIG_IsOK(res1)) {
46941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46942 }
46943 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46944 {
46945 PyThreadState* __tstate = wxPyBeginAllowThreads();
46946 {
46947 wxSize const &_result_ref = (arg1)->GetSpacer();
46948 result = (wxSize *) &_result_ref;
46949 }
46950 wxPyEndAllowThreads(__tstate);
46951 if (PyErr_Occurred()) SWIG_fail;
46952 }
46953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46954 return resultobj;
46955 fail:
46956 return NULL;
46957 }
46958
46959
46960 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46961 PyObject *resultobj = 0;
46962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46963 wxSize *arg2 = 0 ;
46964 void *argp1 = 0 ;
46965 int res1 = 0 ;
46966 wxSize temp2 ;
46967 PyObject * obj0 = 0 ;
46968 PyObject * obj1 = 0 ;
46969 char * kwnames[] = {
46970 (char *) "self",(char *) "size", NULL
46971 };
46972
46973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46975 if (!SWIG_IsOK(res1)) {
46976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46977 }
46978 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46979 {
46980 arg2 = &temp2;
46981 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46982 }
46983 {
46984 PyThreadState* __tstate = wxPyBeginAllowThreads();
46985 (arg1)->SetSpacer((wxSize const &)*arg2);
46986 wxPyEndAllowThreads(__tstate);
46987 if (PyErr_Occurred()) SWIG_fail;
46988 }
46989 resultobj = SWIG_Py_Void();
46990 return resultobj;
46991 fail:
46992 return NULL;
46993 }
46994
46995
46996 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46997 PyObject *resultobj = 0;
46998 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46999 bool arg2 ;
47000 void *argp1 = 0 ;
47001 int res1 = 0 ;
47002 bool val2 ;
47003 int ecode2 = 0 ;
47004 PyObject * obj0 = 0 ;
47005 PyObject * obj1 = 0 ;
47006 char * kwnames[] = {
47007 (char *) "self",(char *) "show", NULL
47008 };
47009
47010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47012 if (!SWIG_IsOK(res1)) {
47013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47014 }
47015 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47016 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47017 if (!SWIG_IsOK(ecode2)) {
47018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47019 }
47020 arg2 = static_cast< bool >(val2);
47021 {
47022 PyThreadState* __tstate = wxPyBeginAllowThreads();
47023 (arg1)->Show(arg2);
47024 wxPyEndAllowThreads(__tstate);
47025 if (PyErr_Occurred()) SWIG_fail;
47026 }
47027 resultobj = SWIG_Py_Void();
47028 return resultobj;
47029 fail:
47030 return NULL;
47031 }
47032
47033
47034 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47035 PyObject *resultobj = 0;
47036 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47037 bool result;
47038 void *argp1 = 0 ;
47039 int res1 = 0 ;
47040 PyObject *swig_obj[1] ;
47041
47042 if (!args) SWIG_fail;
47043 swig_obj[0] = args;
47044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47045 if (!SWIG_IsOK(res1)) {
47046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47047 }
47048 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47049 {
47050 PyThreadState* __tstate = wxPyBeginAllowThreads();
47051 result = (bool)(arg1)->IsShown();
47052 wxPyEndAllowThreads(__tstate);
47053 if (PyErr_Occurred()) SWIG_fail;
47054 }
47055 {
47056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47057 }
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47065 PyObject *resultobj = 0;
47066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47067 wxPoint result;
47068 void *argp1 = 0 ;
47069 int res1 = 0 ;
47070 PyObject *swig_obj[1] ;
47071
47072 if (!args) SWIG_fail;
47073 swig_obj[0] = args;
47074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47075 if (!SWIG_IsOK(res1)) {
47076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47077 }
47078 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47079 {
47080 PyThreadState* __tstate = wxPyBeginAllowThreads();
47081 result = (arg1)->GetPosition();
47082 wxPyEndAllowThreads(__tstate);
47083 if (PyErr_Occurred()) SWIG_fail;
47084 }
47085 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47086 return resultobj;
47087 fail:
47088 return NULL;
47089 }
47090
47091
47092 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47093 PyObject *resultobj = 0;
47094 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47095 PyObject *result = 0 ;
47096 void *argp1 = 0 ;
47097 int res1 = 0 ;
47098 PyObject *swig_obj[1] ;
47099
47100 if (!args) SWIG_fail;
47101 swig_obj[0] = args;
47102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47103 if (!SWIG_IsOK(res1)) {
47104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47105 }
47106 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47107 {
47108 PyThreadState* __tstate = wxPyBeginAllowThreads();
47109 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47110 wxPyEndAllowThreads(__tstate);
47111 if (PyErr_Occurred()) SWIG_fail;
47112 }
47113 resultobj = result;
47114 return resultobj;
47115 fail:
47116 return NULL;
47117 }
47118
47119
47120 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47121 PyObject *resultobj = 0;
47122 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47123 PyObject *arg2 = (PyObject *) 0 ;
47124 void *argp1 = 0 ;
47125 int res1 = 0 ;
47126 PyObject * obj0 = 0 ;
47127 PyObject * obj1 = 0 ;
47128 char * kwnames[] = {
47129 (char *) "self",(char *) "userData", NULL
47130 };
47131
47132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47134 if (!SWIG_IsOK(res1)) {
47135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47136 }
47137 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47138 arg2 = obj1;
47139 {
47140 PyThreadState* __tstate = wxPyBeginAllowThreads();
47141 wxSizerItem_SetUserData(arg1,arg2);
47142 wxPyEndAllowThreads(__tstate);
47143 if (PyErr_Occurred()) SWIG_fail;
47144 }
47145 resultobj = SWIG_Py_Void();
47146 return resultobj;
47147 fail:
47148 return NULL;
47149 }
47150
47151
47152 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47153 PyObject *obj;
47154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47155 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47156 return SWIG_Py_Void();
47157 }
47158
47159 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47160 return SWIG_Python_InitShadowInstance(args);
47161 }
47162
47163 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47164 PyObject *resultobj = 0;
47165 wxSizer *arg1 = (wxSizer *) 0 ;
47166 void *argp1 = 0 ;
47167 int res1 = 0 ;
47168 PyObject *swig_obj[1] ;
47169
47170 if (!args) SWIG_fail;
47171 swig_obj[0] = args;
47172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47173 if (!SWIG_IsOK(res1)) {
47174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47175 }
47176 arg1 = reinterpret_cast< wxSizer * >(argp1);
47177 {
47178 PyThreadState* __tstate = wxPyBeginAllowThreads();
47179 delete arg1;
47180
47181 wxPyEndAllowThreads(__tstate);
47182 if (PyErr_Occurred()) SWIG_fail;
47183 }
47184 resultobj = SWIG_Py_Void();
47185 return resultobj;
47186 fail:
47187 return NULL;
47188 }
47189
47190
47191 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47192 PyObject *resultobj = 0;
47193 wxSizer *arg1 = (wxSizer *) 0 ;
47194 PyObject *arg2 = (PyObject *) 0 ;
47195 void *argp1 = 0 ;
47196 int res1 = 0 ;
47197 PyObject * obj0 = 0 ;
47198 PyObject * obj1 = 0 ;
47199 char * kwnames[] = {
47200 (char *) "self",(char *) "_self", NULL
47201 };
47202
47203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47205 if (!SWIG_IsOK(res1)) {
47206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47207 }
47208 arg1 = reinterpret_cast< wxSizer * >(argp1);
47209 arg2 = obj1;
47210 {
47211 PyThreadState* __tstate = wxPyBeginAllowThreads();
47212 wxSizer__setOORInfo(arg1,arg2);
47213 wxPyEndAllowThreads(__tstate);
47214 if (PyErr_Occurred()) SWIG_fail;
47215 }
47216 resultobj = SWIG_Py_Void();
47217 return resultobj;
47218 fail:
47219 return NULL;
47220 }
47221
47222
47223 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47224 PyObject *resultobj = 0;
47225 wxSizer *arg1 = (wxSizer *) 0 ;
47226 PyObject *arg2 = (PyObject *) 0 ;
47227 int arg3 = (int) 0 ;
47228 int arg4 = (int) 0 ;
47229 int arg5 = (int) 0 ;
47230 PyObject *arg6 = (PyObject *) NULL ;
47231 wxSizerItem *result = 0 ;
47232 void *argp1 = 0 ;
47233 int res1 = 0 ;
47234 int val3 ;
47235 int ecode3 = 0 ;
47236 int val4 ;
47237 int ecode4 = 0 ;
47238 int val5 ;
47239 int ecode5 = 0 ;
47240 PyObject * obj0 = 0 ;
47241 PyObject * obj1 = 0 ;
47242 PyObject * obj2 = 0 ;
47243 PyObject * obj3 = 0 ;
47244 PyObject * obj4 = 0 ;
47245 PyObject * obj5 = 0 ;
47246 char * kwnames[] = {
47247 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47248 };
47249
47250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47252 if (!SWIG_IsOK(res1)) {
47253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47254 }
47255 arg1 = reinterpret_cast< wxSizer * >(argp1);
47256 arg2 = obj1;
47257 if (obj2) {
47258 ecode3 = SWIG_AsVal_int(obj2, &val3);
47259 if (!SWIG_IsOK(ecode3)) {
47260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47261 }
47262 arg3 = static_cast< int >(val3);
47263 }
47264 if (obj3) {
47265 ecode4 = SWIG_AsVal_int(obj3, &val4);
47266 if (!SWIG_IsOK(ecode4)) {
47267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47268 }
47269 arg4 = static_cast< int >(val4);
47270 }
47271 if (obj4) {
47272 ecode5 = SWIG_AsVal_int(obj4, &val5);
47273 if (!SWIG_IsOK(ecode5)) {
47274 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47275 }
47276 arg5 = static_cast< int >(val5);
47277 }
47278 if (obj5) {
47279 arg6 = obj5;
47280 }
47281 {
47282 PyThreadState* __tstate = wxPyBeginAllowThreads();
47283 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47284 wxPyEndAllowThreads(__tstate);
47285 if (PyErr_Occurred()) SWIG_fail;
47286 }
47287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47288 return resultobj;
47289 fail:
47290 return NULL;
47291 }
47292
47293
47294 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47295 PyObject *resultobj = 0;
47296 wxSizer *arg1 = (wxSizer *) 0 ;
47297 int arg2 ;
47298 PyObject *arg3 = (PyObject *) 0 ;
47299 int arg4 = (int) 0 ;
47300 int arg5 = (int) 0 ;
47301 int arg6 = (int) 0 ;
47302 PyObject *arg7 = (PyObject *) NULL ;
47303 wxSizerItem *result = 0 ;
47304 void *argp1 = 0 ;
47305 int res1 = 0 ;
47306 int val2 ;
47307 int ecode2 = 0 ;
47308 int val4 ;
47309 int ecode4 = 0 ;
47310 int val5 ;
47311 int ecode5 = 0 ;
47312 int val6 ;
47313 int ecode6 = 0 ;
47314 PyObject * obj0 = 0 ;
47315 PyObject * obj1 = 0 ;
47316 PyObject * obj2 = 0 ;
47317 PyObject * obj3 = 0 ;
47318 PyObject * obj4 = 0 ;
47319 PyObject * obj5 = 0 ;
47320 PyObject * obj6 = 0 ;
47321 char * kwnames[] = {
47322 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47323 };
47324
47325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47327 if (!SWIG_IsOK(res1)) {
47328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47329 }
47330 arg1 = reinterpret_cast< wxSizer * >(argp1);
47331 ecode2 = SWIG_AsVal_int(obj1, &val2);
47332 if (!SWIG_IsOK(ecode2)) {
47333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47334 }
47335 arg2 = static_cast< int >(val2);
47336 arg3 = obj2;
47337 if (obj3) {
47338 ecode4 = SWIG_AsVal_int(obj3, &val4);
47339 if (!SWIG_IsOK(ecode4)) {
47340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47341 }
47342 arg4 = static_cast< int >(val4);
47343 }
47344 if (obj4) {
47345 ecode5 = SWIG_AsVal_int(obj4, &val5);
47346 if (!SWIG_IsOK(ecode5)) {
47347 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47348 }
47349 arg5 = static_cast< int >(val5);
47350 }
47351 if (obj5) {
47352 ecode6 = SWIG_AsVal_int(obj5, &val6);
47353 if (!SWIG_IsOK(ecode6)) {
47354 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47355 }
47356 arg6 = static_cast< int >(val6);
47357 }
47358 if (obj6) {
47359 arg7 = obj6;
47360 }
47361 {
47362 PyThreadState* __tstate = wxPyBeginAllowThreads();
47363 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47364 wxPyEndAllowThreads(__tstate);
47365 if (PyErr_Occurred()) SWIG_fail;
47366 }
47367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47368 return resultobj;
47369 fail:
47370 return NULL;
47371 }
47372
47373
47374 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47375 PyObject *resultobj = 0;
47376 wxSizer *arg1 = (wxSizer *) 0 ;
47377 PyObject *arg2 = (PyObject *) 0 ;
47378 int arg3 = (int) 0 ;
47379 int arg4 = (int) 0 ;
47380 int arg5 = (int) 0 ;
47381 PyObject *arg6 = (PyObject *) NULL ;
47382 wxSizerItem *result = 0 ;
47383 void *argp1 = 0 ;
47384 int res1 = 0 ;
47385 int val3 ;
47386 int ecode3 = 0 ;
47387 int val4 ;
47388 int ecode4 = 0 ;
47389 int val5 ;
47390 int ecode5 = 0 ;
47391 PyObject * obj0 = 0 ;
47392 PyObject * obj1 = 0 ;
47393 PyObject * obj2 = 0 ;
47394 PyObject * obj3 = 0 ;
47395 PyObject * obj4 = 0 ;
47396 PyObject * obj5 = 0 ;
47397 char * kwnames[] = {
47398 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47399 };
47400
47401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47403 if (!SWIG_IsOK(res1)) {
47404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47405 }
47406 arg1 = reinterpret_cast< wxSizer * >(argp1);
47407 arg2 = obj1;
47408 if (obj2) {
47409 ecode3 = SWIG_AsVal_int(obj2, &val3);
47410 if (!SWIG_IsOK(ecode3)) {
47411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47412 }
47413 arg3 = static_cast< int >(val3);
47414 }
47415 if (obj3) {
47416 ecode4 = SWIG_AsVal_int(obj3, &val4);
47417 if (!SWIG_IsOK(ecode4)) {
47418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47419 }
47420 arg4 = static_cast< int >(val4);
47421 }
47422 if (obj4) {
47423 ecode5 = SWIG_AsVal_int(obj4, &val5);
47424 if (!SWIG_IsOK(ecode5)) {
47425 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47426 }
47427 arg5 = static_cast< int >(val5);
47428 }
47429 if (obj5) {
47430 arg6 = obj5;
47431 }
47432 {
47433 PyThreadState* __tstate = wxPyBeginAllowThreads();
47434 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47435 wxPyEndAllowThreads(__tstate);
47436 if (PyErr_Occurred()) SWIG_fail;
47437 }
47438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47439 return resultobj;
47440 fail:
47441 return NULL;
47442 }
47443
47444
47445 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47446 PyObject *resultobj = 0;
47447 wxSizer *arg1 = (wxSizer *) 0 ;
47448 PyObject *arg2 = (PyObject *) 0 ;
47449 bool result;
47450 void *argp1 = 0 ;
47451 int res1 = 0 ;
47452 PyObject * obj0 = 0 ;
47453 PyObject * obj1 = 0 ;
47454 char * kwnames[] = {
47455 (char *) "self",(char *) "item", NULL
47456 };
47457
47458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47460 if (!SWIG_IsOK(res1)) {
47461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47462 }
47463 arg1 = reinterpret_cast< wxSizer * >(argp1);
47464 arg2 = obj1;
47465 {
47466 PyThreadState* __tstate = wxPyBeginAllowThreads();
47467 result = (bool)wxSizer_Remove(arg1,arg2);
47468 wxPyEndAllowThreads(__tstate);
47469 if (PyErr_Occurred()) SWIG_fail;
47470 }
47471 {
47472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47473 }
47474 return resultobj;
47475 fail:
47476 return NULL;
47477 }
47478
47479
47480 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47481 PyObject *resultobj = 0;
47482 wxSizer *arg1 = (wxSizer *) 0 ;
47483 PyObject *arg2 = (PyObject *) 0 ;
47484 bool result;
47485 void *argp1 = 0 ;
47486 int res1 = 0 ;
47487 PyObject * obj0 = 0 ;
47488 PyObject * obj1 = 0 ;
47489 char * kwnames[] = {
47490 (char *) "self",(char *) "item", NULL
47491 };
47492
47493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47495 if (!SWIG_IsOK(res1)) {
47496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47497 }
47498 arg1 = reinterpret_cast< wxSizer * >(argp1);
47499 arg2 = obj1;
47500 {
47501 PyThreadState* __tstate = wxPyBeginAllowThreads();
47502 result = (bool)wxSizer_Detach(arg1,arg2);
47503 wxPyEndAllowThreads(__tstate);
47504 if (PyErr_Occurred()) SWIG_fail;
47505 }
47506 {
47507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47508 }
47509 return resultobj;
47510 fail:
47511 return NULL;
47512 }
47513
47514
47515 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47516 PyObject *resultobj = 0;
47517 wxSizer *arg1 = (wxSizer *) 0 ;
47518 PyObject *arg2 = (PyObject *) 0 ;
47519 wxSizerItem *result = 0 ;
47520 void *argp1 = 0 ;
47521 int res1 = 0 ;
47522 PyObject * obj0 = 0 ;
47523 PyObject * obj1 = 0 ;
47524 char * kwnames[] = {
47525 (char *) "self",(char *) "item", NULL
47526 };
47527
47528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47530 if (!SWIG_IsOK(res1)) {
47531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47532 }
47533 arg1 = reinterpret_cast< wxSizer * >(argp1);
47534 arg2 = obj1;
47535 {
47536 PyThreadState* __tstate = wxPyBeginAllowThreads();
47537 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47538 wxPyEndAllowThreads(__tstate);
47539 if (PyErr_Occurred()) SWIG_fail;
47540 }
47541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47542 return resultobj;
47543 fail:
47544 return NULL;
47545 }
47546
47547
47548 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47549 PyObject *resultobj = 0;
47550 wxSizer *arg1 = (wxSizer *) 0 ;
47551 PyObject *arg2 = (PyObject *) 0 ;
47552 wxSize *arg3 = 0 ;
47553 void *argp1 = 0 ;
47554 int res1 = 0 ;
47555 wxSize temp3 ;
47556 PyObject * obj0 = 0 ;
47557 PyObject * obj1 = 0 ;
47558 PyObject * obj2 = 0 ;
47559 char * kwnames[] = {
47560 (char *) "self",(char *) "item",(char *) "size", NULL
47561 };
47562
47563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47565 if (!SWIG_IsOK(res1)) {
47566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47567 }
47568 arg1 = reinterpret_cast< wxSizer * >(argp1);
47569 arg2 = obj1;
47570 {
47571 arg3 = &temp3;
47572 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47573 }
47574 {
47575 PyThreadState* __tstate = wxPyBeginAllowThreads();
47576 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47577 wxPyEndAllowThreads(__tstate);
47578 if (PyErr_Occurred()) SWIG_fail;
47579 }
47580 resultobj = SWIG_Py_Void();
47581 return resultobj;
47582 fail:
47583 return NULL;
47584 }
47585
47586
47587 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47588 PyObject *resultobj = 0;
47589 wxSizer *arg1 = (wxSizer *) 0 ;
47590 wxWindow *arg2 = (wxWindow *) 0 ;
47591 wxWindow *arg3 = (wxWindow *) 0 ;
47592 bool arg4 = (bool) false ;
47593 bool result;
47594 void *argp1 = 0 ;
47595 int res1 = 0 ;
47596 void *argp2 = 0 ;
47597 int res2 = 0 ;
47598 void *argp3 = 0 ;
47599 int res3 = 0 ;
47600 bool val4 ;
47601 int ecode4 = 0 ;
47602 PyObject * obj0 = 0 ;
47603 PyObject * obj1 = 0 ;
47604 PyObject * obj2 = 0 ;
47605 PyObject * obj3 = 0 ;
47606 char * kwnames[] = {
47607 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47608 };
47609
47610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47612 if (!SWIG_IsOK(res1)) {
47613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47614 }
47615 arg1 = reinterpret_cast< wxSizer * >(argp1);
47616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47617 if (!SWIG_IsOK(res2)) {
47618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47619 }
47620 arg2 = reinterpret_cast< wxWindow * >(argp2);
47621 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47622 if (!SWIG_IsOK(res3)) {
47623 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47624 }
47625 arg3 = reinterpret_cast< wxWindow * >(argp3);
47626 if (obj3) {
47627 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47628 if (!SWIG_IsOK(ecode4)) {
47629 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47630 }
47631 arg4 = static_cast< bool >(val4);
47632 }
47633 {
47634 PyThreadState* __tstate = wxPyBeginAllowThreads();
47635 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47636 wxPyEndAllowThreads(__tstate);
47637 if (PyErr_Occurred()) SWIG_fail;
47638 }
47639 {
47640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47641 }
47642 return resultobj;
47643 fail:
47644 return NULL;
47645 }
47646
47647
47648 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47649 PyObject *resultobj = 0;
47650 wxSizer *arg1 = (wxSizer *) 0 ;
47651 wxSizer *arg2 = (wxSizer *) 0 ;
47652 wxSizer *arg3 = (wxSizer *) 0 ;
47653 bool arg4 = (bool) false ;
47654 bool result;
47655 void *argp1 = 0 ;
47656 int res1 = 0 ;
47657 void *argp2 = 0 ;
47658 int res2 = 0 ;
47659 void *argp3 = 0 ;
47660 int res3 = 0 ;
47661 bool val4 ;
47662 int ecode4 = 0 ;
47663 PyObject * obj0 = 0 ;
47664 PyObject * obj1 = 0 ;
47665 PyObject * obj2 = 0 ;
47666 PyObject * obj3 = 0 ;
47667 char * kwnames[] = {
47668 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47669 };
47670
47671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47673 if (!SWIG_IsOK(res1)) {
47674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47675 }
47676 arg1 = reinterpret_cast< wxSizer * >(argp1);
47677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47678 if (!SWIG_IsOK(res2)) {
47679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47680 }
47681 arg2 = reinterpret_cast< wxSizer * >(argp2);
47682 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47683 if (!SWIG_IsOK(res3)) {
47684 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47685 }
47686 arg3 = reinterpret_cast< wxSizer * >(argp3);
47687 if (obj3) {
47688 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47689 if (!SWIG_IsOK(ecode4)) {
47690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47691 }
47692 arg4 = static_cast< bool >(val4);
47693 }
47694 {
47695 PyThreadState* __tstate = wxPyBeginAllowThreads();
47696 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47697 wxPyEndAllowThreads(__tstate);
47698 if (PyErr_Occurred()) SWIG_fail;
47699 }
47700 {
47701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47702 }
47703 return resultobj;
47704 fail:
47705 return NULL;
47706 }
47707
47708
47709 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47710 PyObject *resultobj = 0;
47711 wxSizer *arg1 = (wxSizer *) 0 ;
47712 size_t arg2 ;
47713 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47714 bool result;
47715 void *argp1 = 0 ;
47716 int res1 = 0 ;
47717 size_t val2 ;
47718 int ecode2 = 0 ;
47719 void *argp3 = 0 ;
47720 int res3 = 0 ;
47721 PyObject * obj0 = 0 ;
47722 PyObject * obj1 = 0 ;
47723 PyObject * obj2 = 0 ;
47724 char * kwnames[] = {
47725 (char *) "self",(char *) "index",(char *) "newitem", NULL
47726 };
47727
47728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47730 if (!SWIG_IsOK(res1)) {
47731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47732 }
47733 arg1 = reinterpret_cast< wxSizer * >(argp1);
47734 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47735 if (!SWIG_IsOK(ecode2)) {
47736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47737 }
47738 arg2 = static_cast< size_t >(val2);
47739 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47740 if (!SWIG_IsOK(res3)) {
47741 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47742 }
47743 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47744 {
47745 PyThreadState* __tstate = wxPyBeginAllowThreads();
47746 result = (bool)(arg1)->Replace(arg2,arg3);
47747 wxPyEndAllowThreads(__tstate);
47748 if (PyErr_Occurred()) SWIG_fail;
47749 }
47750 {
47751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47752 }
47753 return resultobj;
47754 fail:
47755 return NULL;
47756 }
47757
47758
47759 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47760 PyObject *resultobj = 0;
47761 wxSizer *arg1 = (wxSizer *) 0 ;
47762 wxWindow *arg2 = (wxWindow *) 0 ;
47763 void *argp1 = 0 ;
47764 int res1 = 0 ;
47765 void *argp2 = 0 ;
47766 int res2 = 0 ;
47767 PyObject * obj0 = 0 ;
47768 PyObject * obj1 = 0 ;
47769 char * kwnames[] = {
47770 (char *) "self",(char *) "window", NULL
47771 };
47772
47773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47775 if (!SWIG_IsOK(res1)) {
47776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47777 }
47778 arg1 = reinterpret_cast< wxSizer * >(argp1);
47779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47780 if (!SWIG_IsOK(res2)) {
47781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47782 }
47783 arg2 = reinterpret_cast< wxWindow * >(argp2);
47784 {
47785 PyThreadState* __tstate = wxPyBeginAllowThreads();
47786 (arg1)->SetContainingWindow(arg2);
47787 wxPyEndAllowThreads(__tstate);
47788 if (PyErr_Occurred()) SWIG_fail;
47789 }
47790 resultobj = SWIG_Py_Void();
47791 return resultobj;
47792 fail:
47793 return NULL;
47794 }
47795
47796
47797 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47798 PyObject *resultobj = 0;
47799 wxSizer *arg1 = (wxSizer *) 0 ;
47800 wxWindow *result = 0 ;
47801 void *argp1 = 0 ;
47802 int res1 = 0 ;
47803 PyObject *swig_obj[1] ;
47804
47805 if (!args) SWIG_fail;
47806 swig_obj[0] = args;
47807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47808 if (!SWIG_IsOK(res1)) {
47809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47810 }
47811 arg1 = reinterpret_cast< wxSizer * >(argp1);
47812 {
47813 PyThreadState* __tstate = wxPyBeginAllowThreads();
47814 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47815 wxPyEndAllowThreads(__tstate);
47816 if (PyErr_Occurred()) SWIG_fail;
47817 }
47818 {
47819 resultobj = wxPyMake_wxObject(result, 0);
47820 }
47821 return resultobj;
47822 fail:
47823 return NULL;
47824 }
47825
47826
47827 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47828 PyObject *resultobj = 0;
47829 wxSizer *arg1 = (wxSizer *) 0 ;
47830 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47831 wxSizerItem *result = 0 ;
47832 void *argp1 = 0 ;
47833 int res1 = 0 ;
47834 int res2 = 0 ;
47835 PyObject * obj0 = 0 ;
47836 PyObject * obj1 = 0 ;
47837 char * kwnames[] = {
47838 (char *) "self",(char *) "item", NULL
47839 };
47840
47841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47843 if (!SWIG_IsOK(res1)) {
47844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47845 }
47846 arg1 = reinterpret_cast< wxSizer * >(argp1);
47847 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47848 if (!SWIG_IsOK(res2)) {
47849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47850 }
47851 {
47852 PyThreadState* __tstate = wxPyBeginAllowThreads();
47853 result = (wxSizerItem *)(arg1)->Add(arg2);
47854 wxPyEndAllowThreads(__tstate);
47855 if (PyErr_Occurred()) SWIG_fail;
47856 }
47857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47858 return resultobj;
47859 fail:
47860 return NULL;
47861 }
47862
47863
47864 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47865 PyObject *resultobj = 0;
47866 wxSizer *arg1 = (wxSizer *) 0 ;
47867 size_t arg2 ;
47868 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47869 wxSizerItem *result = 0 ;
47870 void *argp1 = 0 ;
47871 int res1 = 0 ;
47872 size_t val2 ;
47873 int ecode2 = 0 ;
47874 int res3 = 0 ;
47875 PyObject * obj0 = 0 ;
47876 PyObject * obj1 = 0 ;
47877 PyObject * obj2 = 0 ;
47878 char * kwnames[] = {
47879 (char *) "self",(char *) "index",(char *) "item", NULL
47880 };
47881
47882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47884 if (!SWIG_IsOK(res1)) {
47885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47886 }
47887 arg1 = reinterpret_cast< wxSizer * >(argp1);
47888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47889 if (!SWIG_IsOK(ecode2)) {
47890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47891 }
47892 arg2 = static_cast< size_t >(val2);
47893 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47894 if (!SWIG_IsOK(res3)) {
47895 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47896 }
47897 {
47898 PyThreadState* __tstate = wxPyBeginAllowThreads();
47899 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47900 wxPyEndAllowThreads(__tstate);
47901 if (PyErr_Occurred()) SWIG_fail;
47902 }
47903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47904 return resultobj;
47905 fail:
47906 return NULL;
47907 }
47908
47909
47910 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47911 PyObject *resultobj = 0;
47912 wxSizer *arg1 = (wxSizer *) 0 ;
47913 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47914 wxSizerItem *result = 0 ;
47915 void *argp1 = 0 ;
47916 int res1 = 0 ;
47917 int res2 = 0 ;
47918 PyObject * obj0 = 0 ;
47919 PyObject * obj1 = 0 ;
47920 char * kwnames[] = {
47921 (char *) "self",(char *) "item", NULL
47922 };
47923
47924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47926 if (!SWIG_IsOK(res1)) {
47927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47928 }
47929 arg1 = reinterpret_cast< wxSizer * >(argp1);
47930 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47931 if (!SWIG_IsOK(res2)) {
47932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47933 }
47934 {
47935 PyThreadState* __tstate = wxPyBeginAllowThreads();
47936 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47937 wxPyEndAllowThreads(__tstate);
47938 if (PyErr_Occurred()) SWIG_fail;
47939 }
47940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47941 return resultobj;
47942 fail:
47943 return NULL;
47944 }
47945
47946
47947 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47948 PyObject *resultobj = 0;
47949 wxSizer *arg1 = (wxSizer *) 0 ;
47950 int arg2 ;
47951 int arg3 ;
47952 int arg4 ;
47953 int arg5 ;
47954 void *argp1 = 0 ;
47955 int res1 = 0 ;
47956 int val2 ;
47957 int ecode2 = 0 ;
47958 int val3 ;
47959 int ecode3 = 0 ;
47960 int val4 ;
47961 int ecode4 = 0 ;
47962 int val5 ;
47963 int ecode5 = 0 ;
47964 PyObject * obj0 = 0 ;
47965 PyObject * obj1 = 0 ;
47966 PyObject * obj2 = 0 ;
47967 PyObject * obj3 = 0 ;
47968 PyObject * obj4 = 0 ;
47969 char * kwnames[] = {
47970 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47971 };
47972
47973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47975 if (!SWIG_IsOK(res1)) {
47976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47977 }
47978 arg1 = reinterpret_cast< wxSizer * >(argp1);
47979 ecode2 = SWIG_AsVal_int(obj1, &val2);
47980 if (!SWIG_IsOK(ecode2)) {
47981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47982 }
47983 arg2 = static_cast< int >(val2);
47984 ecode3 = SWIG_AsVal_int(obj2, &val3);
47985 if (!SWIG_IsOK(ecode3)) {
47986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47987 }
47988 arg3 = static_cast< int >(val3);
47989 ecode4 = SWIG_AsVal_int(obj3, &val4);
47990 if (!SWIG_IsOK(ecode4)) {
47991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47992 }
47993 arg4 = static_cast< int >(val4);
47994 ecode5 = SWIG_AsVal_int(obj4, &val5);
47995 if (!SWIG_IsOK(ecode5)) {
47996 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47997 }
47998 arg5 = static_cast< int >(val5);
47999 {
48000 PyThreadState* __tstate = wxPyBeginAllowThreads();
48001 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48002 wxPyEndAllowThreads(__tstate);
48003 if (PyErr_Occurred()) SWIG_fail;
48004 }
48005 resultobj = SWIG_Py_Void();
48006 return resultobj;
48007 fail:
48008 return NULL;
48009 }
48010
48011
48012 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48013 PyObject *resultobj = 0;
48014 wxSizer *arg1 = (wxSizer *) 0 ;
48015 wxSize *arg2 = 0 ;
48016 void *argp1 = 0 ;
48017 int res1 = 0 ;
48018 wxSize temp2 ;
48019 PyObject * obj0 = 0 ;
48020 PyObject * obj1 = 0 ;
48021 char * kwnames[] = {
48022 (char *) "self",(char *) "size", NULL
48023 };
48024
48025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48027 if (!SWIG_IsOK(res1)) {
48028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48029 }
48030 arg1 = reinterpret_cast< wxSizer * >(argp1);
48031 {
48032 arg2 = &temp2;
48033 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48034 }
48035 {
48036 PyThreadState* __tstate = wxPyBeginAllowThreads();
48037 (arg1)->SetMinSize((wxSize const &)*arg2);
48038 wxPyEndAllowThreads(__tstate);
48039 if (PyErr_Occurred()) SWIG_fail;
48040 }
48041 resultobj = SWIG_Py_Void();
48042 return resultobj;
48043 fail:
48044 return NULL;
48045 }
48046
48047
48048 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48049 PyObject *resultobj = 0;
48050 wxSizer *arg1 = (wxSizer *) 0 ;
48051 wxSize result;
48052 void *argp1 = 0 ;
48053 int res1 = 0 ;
48054 PyObject *swig_obj[1] ;
48055
48056 if (!args) SWIG_fail;
48057 swig_obj[0] = args;
48058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48059 if (!SWIG_IsOK(res1)) {
48060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48061 }
48062 arg1 = reinterpret_cast< wxSizer * >(argp1);
48063 {
48064 PyThreadState* __tstate = wxPyBeginAllowThreads();
48065 result = (arg1)->GetSize();
48066 wxPyEndAllowThreads(__tstate);
48067 if (PyErr_Occurred()) SWIG_fail;
48068 }
48069 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48070 return resultobj;
48071 fail:
48072 return NULL;
48073 }
48074
48075
48076 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48077 PyObject *resultobj = 0;
48078 wxSizer *arg1 = (wxSizer *) 0 ;
48079 wxPoint result;
48080 void *argp1 = 0 ;
48081 int res1 = 0 ;
48082 PyObject *swig_obj[1] ;
48083
48084 if (!args) SWIG_fail;
48085 swig_obj[0] = args;
48086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48087 if (!SWIG_IsOK(res1)) {
48088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48089 }
48090 arg1 = reinterpret_cast< wxSizer * >(argp1);
48091 {
48092 PyThreadState* __tstate = wxPyBeginAllowThreads();
48093 result = (arg1)->GetPosition();
48094 wxPyEndAllowThreads(__tstate);
48095 if (PyErr_Occurred()) SWIG_fail;
48096 }
48097 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48098 return resultobj;
48099 fail:
48100 return NULL;
48101 }
48102
48103
48104 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48105 PyObject *resultobj = 0;
48106 wxSizer *arg1 = (wxSizer *) 0 ;
48107 wxSize result;
48108 void *argp1 = 0 ;
48109 int res1 = 0 ;
48110 PyObject *swig_obj[1] ;
48111
48112 if (!args) SWIG_fail;
48113 swig_obj[0] = args;
48114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48115 if (!SWIG_IsOK(res1)) {
48116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48117 }
48118 arg1 = reinterpret_cast< wxSizer * >(argp1);
48119 {
48120 PyThreadState* __tstate = wxPyBeginAllowThreads();
48121 result = (arg1)->GetMinSize();
48122 wxPyEndAllowThreads(__tstate);
48123 if (PyErr_Occurred()) SWIG_fail;
48124 }
48125 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48126 return resultobj;
48127 fail:
48128 return NULL;
48129 }
48130
48131
48132 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48133 PyObject *resultobj = 0;
48134 wxSizer *arg1 = (wxSizer *) 0 ;
48135 void *argp1 = 0 ;
48136 int res1 = 0 ;
48137 PyObject *swig_obj[1] ;
48138
48139 if (!args) SWIG_fail;
48140 swig_obj[0] = args;
48141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48142 if (!SWIG_IsOK(res1)) {
48143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48144 }
48145 arg1 = reinterpret_cast< wxSizer * >(argp1);
48146 {
48147 PyThreadState* __tstate = wxPyBeginAllowThreads();
48148 (arg1)->RecalcSizes();
48149 wxPyEndAllowThreads(__tstate);
48150 if (PyErr_Occurred()) SWIG_fail;
48151 }
48152 resultobj = SWIG_Py_Void();
48153 return resultobj;
48154 fail:
48155 return NULL;
48156 }
48157
48158
48159 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48160 PyObject *resultobj = 0;
48161 wxSizer *arg1 = (wxSizer *) 0 ;
48162 wxSize result;
48163 void *argp1 = 0 ;
48164 int res1 = 0 ;
48165 PyObject *swig_obj[1] ;
48166
48167 if (!args) SWIG_fail;
48168 swig_obj[0] = args;
48169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48170 if (!SWIG_IsOK(res1)) {
48171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48172 }
48173 arg1 = reinterpret_cast< wxSizer * >(argp1);
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 result = (arg1)->CalcMin();
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48181 return resultobj;
48182 fail:
48183 return NULL;
48184 }
48185
48186
48187 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48188 PyObject *resultobj = 0;
48189 wxSizer *arg1 = (wxSizer *) 0 ;
48190 void *argp1 = 0 ;
48191 int res1 = 0 ;
48192 PyObject *swig_obj[1] ;
48193
48194 if (!args) SWIG_fail;
48195 swig_obj[0] = args;
48196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48197 if (!SWIG_IsOK(res1)) {
48198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48199 }
48200 arg1 = reinterpret_cast< wxSizer * >(argp1);
48201 {
48202 PyThreadState* __tstate = wxPyBeginAllowThreads();
48203 (arg1)->Layout();
48204 wxPyEndAllowThreads(__tstate);
48205 if (PyErr_Occurred()) SWIG_fail;
48206 }
48207 resultobj = SWIG_Py_Void();
48208 return resultobj;
48209 fail:
48210 return NULL;
48211 }
48212
48213
48214 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48215 PyObject *resultobj = 0;
48216 wxSizer *arg1 = (wxSizer *) 0 ;
48217 wxWindow *arg2 = (wxWindow *) 0 ;
48218 wxSize result;
48219 void *argp1 = 0 ;
48220 int res1 = 0 ;
48221 void *argp2 = 0 ;
48222 int res2 = 0 ;
48223 PyObject * obj0 = 0 ;
48224 PyObject * obj1 = 0 ;
48225 char * kwnames[] = {
48226 (char *) "self",(char *) "window", NULL
48227 };
48228
48229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48231 if (!SWIG_IsOK(res1)) {
48232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48233 }
48234 arg1 = reinterpret_cast< wxSizer * >(argp1);
48235 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48236 if (!SWIG_IsOK(res2)) {
48237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48238 }
48239 arg2 = reinterpret_cast< wxWindow * >(argp2);
48240 {
48241 PyThreadState* __tstate = wxPyBeginAllowThreads();
48242 result = (arg1)->Fit(arg2);
48243 wxPyEndAllowThreads(__tstate);
48244 if (PyErr_Occurred()) SWIG_fail;
48245 }
48246 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48247 return resultobj;
48248 fail:
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48254 PyObject *resultobj = 0;
48255 wxSizer *arg1 = (wxSizer *) 0 ;
48256 wxWindow *arg2 = (wxWindow *) 0 ;
48257 void *argp1 = 0 ;
48258 int res1 = 0 ;
48259 void *argp2 = 0 ;
48260 int res2 = 0 ;
48261 PyObject * obj0 = 0 ;
48262 PyObject * obj1 = 0 ;
48263 char * kwnames[] = {
48264 (char *) "self",(char *) "window", NULL
48265 };
48266
48267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48269 if (!SWIG_IsOK(res1)) {
48270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48271 }
48272 arg1 = reinterpret_cast< wxSizer * >(argp1);
48273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48274 if (!SWIG_IsOK(res2)) {
48275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48276 }
48277 arg2 = reinterpret_cast< wxWindow * >(argp2);
48278 {
48279 PyThreadState* __tstate = wxPyBeginAllowThreads();
48280 (arg1)->FitInside(arg2);
48281 wxPyEndAllowThreads(__tstate);
48282 if (PyErr_Occurred()) SWIG_fail;
48283 }
48284 resultobj = SWIG_Py_Void();
48285 return resultobj;
48286 fail:
48287 return NULL;
48288 }
48289
48290
48291 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48292 PyObject *resultobj = 0;
48293 wxSizer *arg1 = (wxSizer *) 0 ;
48294 wxWindow *arg2 = (wxWindow *) 0 ;
48295 void *argp1 = 0 ;
48296 int res1 = 0 ;
48297 void *argp2 = 0 ;
48298 int res2 = 0 ;
48299 PyObject * obj0 = 0 ;
48300 PyObject * obj1 = 0 ;
48301 char * kwnames[] = {
48302 (char *) "self",(char *) "window", NULL
48303 };
48304
48305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48307 if (!SWIG_IsOK(res1)) {
48308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48309 }
48310 arg1 = reinterpret_cast< wxSizer * >(argp1);
48311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48312 if (!SWIG_IsOK(res2)) {
48313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48314 }
48315 arg2 = reinterpret_cast< wxWindow * >(argp2);
48316 {
48317 PyThreadState* __tstate = wxPyBeginAllowThreads();
48318 (arg1)->SetSizeHints(arg2);
48319 wxPyEndAllowThreads(__tstate);
48320 if (PyErr_Occurred()) SWIG_fail;
48321 }
48322 resultobj = SWIG_Py_Void();
48323 return resultobj;
48324 fail:
48325 return NULL;
48326 }
48327
48328
48329 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48330 PyObject *resultobj = 0;
48331 wxSizer *arg1 = (wxSizer *) 0 ;
48332 wxWindow *arg2 = (wxWindow *) 0 ;
48333 void *argp1 = 0 ;
48334 int res1 = 0 ;
48335 void *argp2 = 0 ;
48336 int res2 = 0 ;
48337 PyObject * obj0 = 0 ;
48338 PyObject * obj1 = 0 ;
48339 char * kwnames[] = {
48340 (char *) "self",(char *) "window", NULL
48341 };
48342
48343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48345 if (!SWIG_IsOK(res1)) {
48346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48347 }
48348 arg1 = reinterpret_cast< wxSizer * >(argp1);
48349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48350 if (!SWIG_IsOK(res2)) {
48351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48352 }
48353 arg2 = reinterpret_cast< wxWindow * >(argp2);
48354 {
48355 PyThreadState* __tstate = wxPyBeginAllowThreads();
48356 (arg1)->SetVirtualSizeHints(arg2);
48357 wxPyEndAllowThreads(__tstate);
48358 if (PyErr_Occurred()) SWIG_fail;
48359 }
48360 resultobj = SWIG_Py_Void();
48361 return resultobj;
48362 fail:
48363 return NULL;
48364 }
48365
48366
48367 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48368 PyObject *resultobj = 0;
48369 wxSizer *arg1 = (wxSizer *) 0 ;
48370 bool arg2 = (bool) false ;
48371 void *argp1 = 0 ;
48372 int res1 = 0 ;
48373 bool val2 ;
48374 int ecode2 = 0 ;
48375 PyObject * obj0 = 0 ;
48376 PyObject * obj1 = 0 ;
48377 char * kwnames[] = {
48378 (char *) "self",(char *) "deleteWindows", NULL
48379 };
48380
48381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48383 if (!SWIG_IsOK(res1)) {
48384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48385 }
48386 arg1 = reinterpret_cast< wxSizer * >(argp1);
48387 if (obj1) {
48388 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48389 if (!SWIG_IsOK(ecode2)) {
48390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48391 }
48392 arg2 = static_cast< bool >(val2);
48393 }
48394 {
48395 PyThreadState* __tstate = wxPyBeginAllowThreads();
48396 (arg1)->Clear(arg2);
48397 wxPyEndAllowThreads(__tstate);
48398 if (PyErr_Occurred()) SWIG_fail;
48399 }
48400 resultobj = SWIG_Py_Void();
48401 return resultobj;
48402 fail:
48403 return NULL;
48404 }
48405
48406
48407 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48408 PyObject *resultobj = 0;
48409 wxSizer *arg1 = (wxSizer *) 0 ;
48410 void *argp1 = 0 ;
48411 int res1 = 0 ;
48412 PyObject *swig_obj[1] ;
48413
48414 if (!args) SWIG_fail;
48415 swig_obj[0] = args;
48416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48417 if (!SWIG_IsOK(res1)) {
48418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48419 }
48420 arg1 = reinterpret_cast< wxSizer * >(argp1);
48421 {
48422 PyThreadState* __tstate = wxPyBeginAllowThreads();
48423 (arg1)->DeleteWindows();
48424 wxPyEndAllowThreads(__tstate);
48425 if (PyErr_Occurred()) SWIG_fail;
48426 }
48427 resultobj = SWIG_Py_Void();
48428 return resultobj;
48429 fail:
48430 return NULL;
48431 }
48432
48433
48434 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48435 PyObject *resultobj = 0;
48436 wxSizer *arg1 = (wxSizer *) 0 ;
48437 PyObject *result = 0 ;
48438 void *argp1 = 0 ;
48439 int res1 = 0 ;
48440 PyObject *swig_obj[1] ;
48441
48442 if (!args) SWIG_fail;
48443 swig_obj[0] = args;
48444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48445 if (!SWIG_IsOK(res1)) {
48446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48447 }
48448 arg1 = reinterpret_cast< wxSizer * >(argp1);
48449 {
48450 PyThreadState* __tstate = wxPyBeginAllowThreads();
48451 result = (PyObject *)wxSizer_GetChildren(arg1);
48452 wxPyEndAllowThreads(__tstate);
48453 if (PyErr_Occurred()) SWIG_fail;
48454 }
48455 resultobj = result;
48456 return resultobj;
48457 fail:
48458 return NULL;
48459 }
48460
48461
48462 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48463 PyObject *resultobj = 0;
48464 wxSizer *arg1 = (wxSizer *) 0 ;
48465 PyObject *arg2 = (PyObject *) 0 ;
48466 bool arg3 = (bool) true ;
48467 bool arg4 = (bool) false ;
48468 bool result;
48469 void *argp1 = 0 ;
48470 int res1 = 0 ;
48471 bool val3 ;
48472 int ecode3 = 0 ;
48473 bool val4 ;
48474 int ecode4 = 0 ;
48475 PyObject * obj0 = 0 ;
48476 PyObject * obj1 = 0 ;
48477 PyObject * obj2 = 0 ;
48478 PyObject * obj3 = 0 ;
48479 char * kwnames[] = {
48480 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48481 };
48482
48483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48485 if (!SWIG_IsOK(res1)) {
48486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48487 }
48488 arg1 = reinterpret_cast< wxSizer * >(argp1);
48489 arg2 = obj1;
48490 if (obj2) {
48491 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48492 if (!SWIG_IsOK(ecode3)) {
48493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48494 }
48495 arg3 = static_cast< bool >(val3);
48496 }
48497 if (obj3) {
48498 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48499 if (!SWIG_IsOK(ecode4)) {
48500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48501 }
48502 arg4 = static_cast< bool >(val4);
48503 }
48504 {
48505 PyThreadState* __tstate = wxPyBeginAllowThreads();
48506 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48507 wxPyEndAllowThreads(__tstate);
48508 if (PyErr_Occurred()) SWIG_fail;
48509 }
48510 {
48511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48512 }
48513 return resultobj;
48514 fail:
48515 return NULL;
48516 }
48517
48518
48519 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48520 PyObject *resultobj = 0;
48521 wxSizer *arg1 = (wxSizer *) 0 ;
48522 PyObject *arg2 = (PyObject *) 0 ;
48523 bool result;
48524 void *argp1 = 0 ;
48525 int res1 = 0 ;
48526 PyObject * obj0 = 0 ;
48527 PyObject * obj1 = 0 ;
48528 char * kwnames[] = {
48529 (char *) "self",(char *) "item", NULL
48530 };
48531
48532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48534 if (!SWIG_IsOK(res1)) {
48535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48536 }
48537 arg1 = reinterpret_cast< wxSizer * >(argp1);
48538 arg2 = obj1;
48539 {
48540 PyThreadState* __tstate = wxPyBeginAllowThreads();
48541 result = (bool)wxSizer_IsShown(arg1,arg2);
48542 wxPyEndAllowThreads(__tstate);
48543 if (PyErr_Occurred()) SWIG_fail;
48544 }
48545 {
48546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48547 }
48548 return resultobj;
48549 fail:
48550 return NULL;
48551 }
48552
48553
48554 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48555 PyObject *resultobj = 0;
48556 wxSizer *arg1 = (wxSizer *) 0 ;
48557 bool arg2 ;
48558 void *argp1 = 0 ;
48559 int res1 = 0 ;
48560 bool val2 ;
48561 int ecode2 = 0 ;
48562 PyObject * obj0 = 0 ;
48563 PyObject * obj1 = 0 ;
48564 char * kwnames[] = {
48565 (char *) "self",(char *) "show", NULL
48566 };
48567
48568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48572 }
48573 arg1 = reinterpret_cast< wxSizer * >(argp1);
48574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48575 if (!SWIG_IsOK(ecode2)) {
48576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48577 }
48578 arg2 = static_cast< bool >(val2);
48579 {
48580 PyThreadState* __tstate = wxPyBeginAllowThreads();
48581 (arg1)->ShowItems(arg2);
48582 wxPyEndAllowThreads(__tstate);
48583 if (PyErr_Occurred()) SWIG_fail;
48584 }
48585 resultobj = SWIG_Py_Void();
48586 return resultobj;
48587 fail:
48588 return NULL;
48589 }
48590
48591
48592 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48593 PyObject *obj;
48594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48595 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48596 return SWIG_Py_Void();
48597 }
48598
48599 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48600 PyObject *resultobj = 0;
48601 wxPySizer *result = 0 ;
48602
48603 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48604 {
48605 PyThreadState* __tstate = wxPyBeginAllowThreads();
48606 result = (wxPySizer *)new wxPySizer();
48607 wxPyEndAllowThreads(__tstate);
48608 if (PyErr_Occurred()) SWIG_fail;
48609 }
48610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48611 return resultobj;
48612 fail:
48613 return NULL;
48614 }
48615
48616
48617 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48618 PyObject *resultobj = 0;
48619 wxPySizer *arg1 = (wxPySizer *) 0 ;
48620 PyObject *arg2 = (PyObject *) 0 ;
48621 PyObject *arg3 = (PyObject *) 0 ;
48622 void *argp1 = 0 ;
48623 int res1 = 0 ;
48624 PyObject * obj0 = 0 ;
48625 PyObject * obj1 = 0 ;
48626 PyObject * obj2 = 0 ;
48627 char * kwnames[] = {
48628 (char *) "self",(char *) "self",(char *) "_class", NULL
48629 };
48630
48631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48633 if (!SWIG_IsOK(res1)) {
48634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48635 }
48636 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48637 arg2 = obj1;
48638 arg3 = obj2;
48639 {
48640 PyThreadState* __tstate = wxPyBeginAllowThreads();
48641 (arg1)->_setCallbackInfo(arg2,arg3);
48642 wxPyEndAllowThreads(__tstate);
48643 if (PyErr_Occurred()) SWIG_fail;
48644 }
48645 resultobj = SWIG_Py_Void();
48646 return resultobj;
48647 fail:
48648 return NULL;
48649 }
48650
48651
48652 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48653 PyObject *obj;
48654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48655 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48656 return SWIG_Py_Void();
48657 }
48658
48659 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48660 return SWIG_Python_InitShadowInstance(args);
48661 }
48662
48663 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48664 PyObject *resultobj = 0;
48665 int arg1 = (int) wxHORIZONTAL ;
48666 wxBoxSizer *result = 0 ;
48667 int val1 ;
48668 int ecode1 = 0 ;
48669 PyObject * obj0 = 0 ;
48670 char * kwnames[] = {
48671 (char *) "orient", NULL
48672 };
48673
48674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48675 if (obj0) {
48676 ecode1 = SWIG_AsVal_int(obj0, &val1);
48677 if (!SWIG_IsOK(ecode1)) {
48678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48679 }
48680 arg1 = static_cast< int >(val1);
48681 }
48682 {
48683 PyThreadState* __tstate = wxPyBeginAllowThreads();
48684 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48685 wxPyEndAllowThreads(__tstate);
48686 if (PyErr_Occurred()) SWIG_fail;
48687 }
48688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48689 return resultobj;
48690 fail:
48691 return NULL;
48692 }
48693
48694
48695 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48696 PyObject *resultobj = 0;
48697 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48698 int result;
48699 void *argp1 = 0 ;
48700 int res1 = 0 ;
48701 PyObject *swig_obj[1] ;
48702
48703 if (!args) SWIG_fail;
48704 swig_obj[0] = args;
48705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48706 if (!SWIG_IsOK(res1)) {
48707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48708 }
48709 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48710 {
48711 PyThreadState* __tstate = wxPyBeginAllowThreads();
48712 result = (int)(arg1)->GetOrientation();
48713 wxPyEndAllowThreads(__tstate);
48714 if (PyErr_Occurred()) SWIG_fail;
48715 }
48716 resultobj = SWIG_From_int(static_cast< int >(result));
48717 return resultobj;
48718 fail:
48719 return NULL;
48720 }
48721
48722
48723 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48724 PyObject *resultobj = 0;
48725 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48726 int arg2 ;
48727 void *argp1 = 0 ;
48728 int res1 = 0 ;
48729 int val2 ;
48730 int ecode2 = 0 ;
48731 PyObject * obj0 = 0 ;
48732 PyObject * obj1 = 0 ;
48733 char * kwnames[] = {
48734 (char *) "self",(char *) "orient", NULL
48735 };
48736
48737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48739 if (!SWIG_IsOK(res1)) {
48740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48741 }
48742 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48743 ecode2 = SWIG_AsVal_int(obj1, &val2);
48744 if (!SWIG_IsOK(ecode2)) {
48745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48746 }
48747 arg2 = static_cast< int >(val2);
48748 {
48749 PyThreadState* __tstate = wxPyBeginAllowThreads();
48750 (arg1)->SetOrientation(arg2);
48751 wxPyEndAllowThreads(__tstate);
48752 if (PyErr_Occurred()) SWIG_fail;
48753 }
48754 resultobj = SWIG_Py_Void();
48755 return resultobj;
48756 fail:
48757 return NULL;
48758 }
48759
48760
48761 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48762 PyObject *obj;
48763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48764 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48765 return SWIG_Py_Void();
48766 }
48767
48768 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48769 return SWIG_Python_InitShadowInstance(args);
48770 }
48771
48772 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48773 PyObject *resultobj = 0;
48774 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48775 int arg2 = (int) wxHORIZONTAL ;
48776 wxStaticBoxSizer *result = 0 ;
48777 void *argp1 = 0 ;
48778 int res1 = 0 ;
48779 int val2 ;
48780 int ecode2 = 0 ;
48781 PyObject * obj0 = 0 ;
48782 PyObject * obj1 = 0 ;
48783 char * kwnames[] = {
48784 (char *) "box",(char *) "orient", NULL
48785 };
48786
48787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48789 if (!SWIG_IsOK(res1)) {
48790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48791 }
48792 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48793 if (obj1) {
48794 ecode2 = SWIG_AsVal_int(obj1, &val2);
48795 if (!SWIG_IsOK(ecode2)) {
48796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48797 }
48798 arg2 = static_cast< int >(val2);
48799 }
48800 {
48801 PyThreadState* __tstate = wxPyBeginAllowThreads();
48802 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48803 wxPyEndAllowThreads(__tstate);
48804 if (PyErr_Occurred()) SWIG_fail;
48805 }
48806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48807 return resultobj;
48808 fail:
48809 return NULL;
48810 }
48811
48812
48813 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48814 PyObject *resultobj = 0;
48815 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48816 wxStaticBox *result = 0 ;
48817 void *argp1 = 0 ;
48818 int res1 = 0 ;
48819 PyObject *swig_obj[1] ;
48820
48821 if (!args) SWIG_fail;
48822 swig_obj[0] = args;
48823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48824 if (!SWIG_IsOK(res1)) {
48825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48826 }
48827 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48828 {
48829 PyThreadState* __tstate = wxPyBeginAllowThreads();
48830 result = (wxStaticBox *)(arg1)->GetStaticBox();
48831 wxPyEndAllowThreads(__tstate);
48832 if (PyErr_Occurred()) SWIG_fail;
48833 }
48834 {
48835 resultobj = wxPyMake_wxObject(result, (bool)0);
48836 }
48837 return resultobj;
48838 fail:
48839 return NULL;
48840 }
48841
48842
48843 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48844 PyObject *obj;
48845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48846 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48847 return SWIG_Py_Void();
48848 }
48849
48850 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48851 return SWIG_Python_InitShadowInstance(args);
48852 }
48853
48854 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48855 PyObject *resultobj = 0;
48856 int arg1 = (int) 1 ;
48857 int arg2 = (int) 0 ;
48858 int arg3 = (int) 0 ;
48859 int arg4 = (int) 0 ;
48860 wxGridSizer *result = 0 ;
48861 int val1 ;
48862 int ecode1 = 0 ;
48863 int val2 ;
48864 int ecode2 = 0 ;
48865 int val3 ;
48866 int ecode3 = 0 ;
48867 int val4 ;
48868 int ecode4 = 0 ;
48869 PyObject * obj0 = 0 ;
48870 PyObject * obj1 = 0 ;
48871 PyObject * obj2 = 0 ;
48872 PyObject * obj3 = 0 ;
48873 char * kwnames[] = {
48874 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48875 };
48876
48877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48878 if (obj0) {
48879 ecode1 = SWIG_AsVal_int(obj0, &val1);
48880 if (!SWIG_IsOK(ecode1)) {
48881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48882 }
48883 arg1 = static_cast< int >(val1);
48884 }
48885 if (obj1) {
48886 ecode2 = SWIG_AsVal_int(obj1, &val2);
48887 if (!SWIG_IsOK(ecode2)) {
48888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48889 }
48890 arg2 = static_cast< int >(val2);
48891 }
48892 if (obj2) {
48893 ecode3 = SWIG_AsVal_int(obj2, &val3);
48894 if (!SWIG_IsOK(ecode3)) {
48895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48896 }
48897 arg3 = static_cast< int >(val3);
48898 }
48899 if (obj3) {
48900 ecode4 = SWIG_AsVal_int(obj3, &val4);
48901 if (!SWIG_IsOK(ecode4)) {
48902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48903 }
48904 arg4 = static_cast< int >(val4);
48905 }
48906 {
48907 PyThreadState* __tstate = wxPyBeginAllowThreads();
48908 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48909 wxPyEndAllowThreads(__tstate);
48910 if (PyErr_Occurred()) SWIG_fail;
48911 }
48912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48913 return resultobj;
48914 fail:
48915 return NULL;
48916 }
48917
48918
48919 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48920 PyObject *resultobj = 0;
48921 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48922 int arg2 ;
48923 void *argp1 = 0 ;
48924 int res1 = 0 ;
48925 int val2 ;
48926 int ecode2 = 0 ;
48927 PyObject * obj0 = 0 ;
48928 PyObject * obj1 = 0 ;
48929 char * kwnames[] = {
48930 (char *) "self",(char *) "cols", NULL
48931 };
48932
48933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48935 if (!SWIG_IsOK(res1)) {
48936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48937 }
48938 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48939 ecode2 = SWIG_AsVal_int(obj1, &val2);
48940 if (!SWIG_IsOK(ecode2)) {
48941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48942 }
48943 arg2 = static_cast< int >(val2);
48944 {
48945 PyThreadState* __tstate = wxPyBeginAllowThreads();
48946 (arg1)->SetCols(arg2);
48947 wxPyEndAllowThreads(__tstate);
48948 if (PyErr_Occurred()) SWIG_fail;
48949 }
48950 resultobj = SWIG_Py_Void();
48951 return resultobj;
48952 fail:
48953 return NULL;
48954 }
48955
48956
48957 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48958 PyObject *resultobj = 0;
48959 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48960 int arg2 ;
48961 void *argp1 = 0 ;
48962 int res1 = 0 ;
48963 int val2 ;
48964 int ecode2 = 0 ;
48965 PyObject * obj0 = 0 ;
48966 PyObject * obj1 = 0 ;
48967 char * kwnames[] = {
48968 (char *) "self",(char *) "rows", NULL
48969 };
48970
48971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48973 if (!SWIG_IsOK(res1)) {
48974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48975 }
48976 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48977 ecode2 = SWIG_AsVal_int(obj1, &val2);
48978 if (!SWIG_IsOK(ecode2)) {
48979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48980 }
48981 arg2 = static_cast< int >(val2);
48982 {
48983 PyThreadState* __tstate = wxPyBeginAllowThreads();
48984 (arg1)->SetRows(arg2);
48985 wxPyEndAllowThreads(__tstate);
48986 if (PyErr_Occurred()) SWIG_fail;
48987 }
48988 resultobj = SWIG_Py_Void();
48989 return resultobj;
48990 fail:
48991 return NULL;
48992 }
48993
48994
48995 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48996 PyObject *resultobj = 0;
48997 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48998 int arg2 ;
48999 void *argp1 = 0 ;
49000 int res1 = 0 ;
49001 int val2 ;
49002 int ecode2 = 0 ;
49003 PyObject * obj0 = 0 ;
49004 PyObject * obj1 = 0 ;
49005 char * kwnames[] = {
49006 (char *) "self",(char *) "gap", NULL
49007 };
49008
49009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49011 if (!SWIG_IsOK(res1)) {
49012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49013 }
49014 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49015 ecode2 = SWIG_AsVal_int(obj1, &val2);
49016 if (!SWIG_IsOK(ecode2)) {
49017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49018 }
49019 arg2 = static_cast< int >(val2);
49020 {
49021 PyThreadState* __tstate = wxPyBeginAllowThreads();
49022 (arg1)->SetVGap(arg2);
49023 wxPyEndAllowThreads(__tstate);
49024 if (PyErr_Occurred()) SWIG_fail;
49025 }
49026 resultobj = SWIG_Py_Void();
49027 return resultobj;
49028 fail:
49029 return NULL;
49030 }
49031
49032
49033 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49034 PyObject *resultobj = 0;
49035 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49036 int arg2 ;
49037 void *argp1 = 0 ;
49038 int res1 = 0 ;
49039 int val2 ;
49040 int ecode2 = 0 ;
49041 PyObject * obj0 = 0 ;
49042 PyObject * obj1 = 0 ;
49043 char * kwnames[] = {
49044 (char *) "self",(char *) "gap", NULL
49045 };
49046
49047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49049 if (!SWIG_IsOK(res1)) {
49050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49051 }
49052 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49053 ecode2 = SWIG_AsVal_int(obj1, &val2);
49054 if (!SWIG_IsOK(ecode2)) {
49055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49056 }
49057 arg2 = static_cast< int >(val2);
49058 {
49059 PyThreadState* __tstate = wxPyBeginAllowThreads();
49060 (arg1)->SetHGap(arg2);
49061 wxPyEndAllowThreads(__tstate);
49062 if (PyErr_Occurred()) SWIG_fail;
49063 }
49064 resultobj = SWIG_Py_Void();
49065 return resultobj;
49066 fail:
49067 return NULL;
49068 }
49069
49070
49071 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49072 PyObject *resultobj = 0;
49073 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49074 int result;
49075 void *argp1 = 0 ;
49076 int res1 = 0 ;
49077 PyObject *swig_obj[1] ;
49078
49079 if (!args) SWIG_fail;
49080 swig_obj[0] = args;
49081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49082 if (!SWIG_IsOK(res1)) {
49083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49084 }
49085 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49086 {
49087 PyThreadState* __tstate = wxPyBeginAllowThreads();
49088 result = (int)(arg1)->GetCols();
49089 wxPyEndAllowThreads(__tstate);
49090 if (PyErr_Occurred()) SWIG_fail;
49091 }
49092 resultobj = SWIG_From_int(static_cast< int >(result));
49093 return resultobj;
49094 fail:
49095 return NULL;
49096 }
49097
49098
49099 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49100 PyObject *resultobj = 0;
49101 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49102 int result;
49103 void *argp1 = 0 ;
49104 int res1 = 0 ;
49105 PyObject *swig_obj[1] ;
49106
49107 if (!args) SWIG_fail;
49108 swig_obj[0] = args;
49109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49110 if (!SWIG_IsOK(res1)) {
49111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49112 }
49113 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49114 {
49115 PyThreadState* __tstate = wxPyBeginAllowThreads();
49116 result = (int)(arg1)->GetRows();
49117 wxPyEndAllowThreads(__tstate);
49118 if (PyErr_Occurred()) SWIG_fail;
49119 }
49120 resultobj = SWIG_From_int(static_cast< int >(result));
49121 return resultobj;
49122 fail:
49123 return NULL;
49124 }
49125
49126
49127 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49128 PyObject *resultobj = 0;
49129 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49130 int result;
49131 void *argp1 = 0 ;
49132 int res1 = 0 ;
49133 PyObject *swig_obj[1] ;
49134
49135 if (!args) SWIG_fail;
49136 swig_obj[0] = args;
49137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49138 if (!SWIG_IsOK(res1)) {
49139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49140 }
49141 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49142 {
49143 PyThreadState* __tstate = wxPyBeginAllowThreads();
49144 result = (int)(arg1)->GetVGap();
49145 wxPyEndAllowThreads(__tstate);
49146 if (PyErr_Occurred()) SWIG_fail;
49147 }
49148 resultobj = SWIG_From_int(static_cast< int >(result));
49149 return resultobj;
49150 fail:
49151 return NULL;
49152 }
49153
49154
49155 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49156 PyObject *resultobj = 0;
49157 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49158 int result;
49159 void *argp1 = 0 ;
49160 int res1 = 0 ;
49161 PyObject *swig_obj[1] ;
49162
49163 if (!args) SWIG_fail;
49164 swig_obj[0] = args;
49165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49166 if (!SWIG_IsOK(res1)) {
49167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49168 }
49169 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49170 {
49171 PyThreadState* __tstate = wxPyBeginAllowThreads();
49172 result = (int)(arg1)->GetHGap();
49173 wxPyEndAllowThreads(__tstate);
49174 if (PyErr_Occurred()) SWIG_fail;
49175 }
49176 resultobj = SWIG_From_int(static_cast< int >(result));
49177 return resultobj;
49178 fail:
49179 return NULL;
49180 }
49181
49182
49183 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49184 PyObject *obj;
49185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49186 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49187 return SWIG_Py_Void();
49188 }
49189
49190 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49191 return SWIG_Python_InitShadowInstance(args);
49192 }
49193
49194 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49195 PyObject *resultobj = 0;
49196 int arg1 = (int) 1 ;
49197 int arg2 = (int) 0 ;
49198 int arg3 = (int) 0 ;
49199 int arg4 = (int) 0 ;
49200 wxFlexGridSizer *result = 0 ;
49201 int val1 ;
49202 int ecode1 = 0 ;
49203 int val2 ;
49204 int ecode2 = 0 ;
49205 int val3 ;
49206 int ecode3 = 0 ;
49207 int val4 ;
49208 int ecode4 = 0 ;
49209 PyObject * obj0 = 0 ;
49210 PyObject * obj1 = 0 ;
49211 PyObject * obj2 = 0 ;
49212 PyObject * obj3 = 0 ;
49213 char * kwnames[] = {
49214 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49215 };
49216
49217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49218 if (obj0) {
49219 ecode1 = SWIG_AsVal_int(obj0, &val1);
49220 if (!SWIG_IsOK(ecode1)) {
49221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49222 }
49223 arg1 = static_cast< int >(val1);
49224 }
49225 if (obj1) {
49226 ecode2 = SWIG_AsVal_int(obj1, &val2);
49227 if (!SWIG_IsOK(ecode2)) {
49228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49229 }
49230 arg2 = static_cast< int >(val2);
49231 }
49232 if (obj2) {
49233 ecode3 = SWIG_AsVal_int(obj2, &val3);
49234 if (!SWIG_IsOK(ecode3)) {
49235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49236 }
49237 arg3 = static_cast< int >(val3);
49238 }
49239 if (obj3) {
49240 ecode4 = SWIG_AsVal_int(obj3, &val4);
49241 if (!SWIG_IsOK(ecode4)) {
49242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49243 }
49244 arg4 = static_cast< int >(val4);
49245 }
49246 {
49247 PyThreadState* __tstate = wxPyBeginAllowThreads();
49248 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49249 wxPyEndAllowThreads(__tstate);
49250 if (PyErr_Occurred()) SWIG_fail;
49251 }
49252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49260 PyObject *resultobj = 0;
49261 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49262 size_t arg2 ;
49263 int arg3 = (int) 0 ;
49264 void *argp1 = 0 ;
49265 int res1 = 0 ;
49266 size_t val2 ;
49267 int ecode2 = 0 ;
49268 int val3 ;
49269 int ecode3 = 0 ;
49270 PyObject * obj0 = 0 ;
49271 PyObject * obj1 = 0 ;
49272 PyObject * obj2 = 0 ;
49273 char * kwnames[] = {
49274 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49275 };
49276
49277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49279 if (!SWIG_IsOK(res1)) {
49280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49281 }
49282 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49283 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49284 if (!SWIG_IsOK(ecode2)) {
49285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49286 }
49287 arg2 = static_cast< size_t >(val2);
49288 if (obj2) {
49289 ecode3 = SWIG_AsVal_int(obj2, &val3);
49290 if (!SWIG_IsOK(ecode3)) {
49291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49292 }
49293 arg3 = static_cast< int >(val3);
49294 }
49295 {
49296 PyThreadState* __tstate = wxPyBeginAllowThreads();
49297 (arg1)->AddGrowableRow(arg2,arg3);
49298 wxPyEndAllowThreads(__tstate);
49299 if (PyErr_Occurred()) SWIG_fail;
49300 }
49301 resultobj = SWIG_Py_Void();
49302 return resultobj;
49303 fail:
49304 return NULL;
49305 }
49306
49307
49308 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49309 PyObject *resultobj = 0;
49310 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49311 size_t arg2 ;
49312 void *argp1 = 0 ;
49313 int res1 = 0 ;
49314 size_t val2 ;
49315 int ecode2 = 0 ;
49316 PyObject * obj0 = 0 ;
49317 PyObject * obj1 = 0 ;
49318 char * kwnames[] = {
49319 (char *) "self",(char *) "idx", NULL
49320 };
49321
49322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49324 if (!SWIG_IsOK(res1)) {
49325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49326 }
49327 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49328 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49329 if (!SWIG_IsOK(ecode2)) {
49330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49331 }
49332 arg2 = static_cast< size_t >(val2);
49333 {
49334 PyThreadState* __tstate = wxPyBeginAllowThreads();
49335 (arg1)->RemoveGrowableRow(arg2);
49336 wxPyEndAllowThreads(__tstate);
49337 if (PyErr_Occurred()) SWIG_fail;
49338 }
49339 resultobj = SWIG_Py_Void();
49340 return resultobj;
49341 fail:
49342 return NULL;
49343 }
49344
49345
49346 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49347 PyObject *resultobj = 0;
49348 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49349 size_t arg2 ;
49350 int arg3 = (int) 0 ;
49351 void *argp1 = 0 ;
49352 int res1 = 0 ;
49353 size_t val2 ;
49354 int ecode2 = 0 ;
49355 int val3 ;
49356 int ecode3 = 0 ;
49357 PyObject * obj0 = 0 ;
49358 PyObject * obj1 = 0 ;
49359 PyObject * obj2 = 0 ;
49360 char * kwnames[] = {
49361 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49362 };
49363
49364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49366 if (!SWIG_IsOK(res1)) {
49367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49368 }
49369 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49370 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49371 if (!SWIG_IsOK(ecode2)) {
49372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49373 }
49374 arg2 = static_cast< size_t >(val2);
49375 if (obj2) {
49376 ecode3 = SWIG_AsVal_int(obj2, &val3);
49377 if (!SWIG_IsOK(ecode3)) {
49378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49379 }
49380 arg3 = static_cast< int >(val3);
49381 }
49382 {
49383 PyThreadState* __tstate = wxPyBeginAllowThreads();
49384 (arg1)->AddGrowableCol(arg2,arg3);
49385 wxPyEndAllowThreads(__tstate);
49386 if (PyErr_Occurred()) SWIG_fail;
49387 }
49388 resultobj = SWIG_Py_Void();
49389 return resultobj;
49390 fail:
49391 return NULL;
49392 }
49393
49394
49395 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49396 PyObject *resultobj = 0;
49397 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49398 size_t arg2 ;
49399 void *argp1 = 0 ;
49400 int res1 = 0 ;
49401 size_t val2 ;
49402 int ecode2 = 0 ;
49403 PyObject * obj0 = 0 ;
49404 PyObject * obj1 = 0 ;
49405 char * kwnames[] = {
49406 (char *) "self",(char *) "idx", NULL
49407 };
49408
49409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49411 if (!SWIG_IsOK(res1)) {
49412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49413 }
49414 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49415 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49416 if (!SWIG_IsOK(ecode2)) {
49417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49418 }
49419 arg2 = static_cast< size_t >(val2);
49420 {
49421 PyThreadState* __tstate = wxPyBeginAllowThreads();
49422 (arg1)->RemoveGrowableCol(arg2);
49423 wxPyEndAllowThreads(__tstate);
49424 if (PyErr_Occurred()) SWIG_fail;
49425 }
49426 resultobj = SWIG_Py_Void();
49427 return resultobj;
49428 fail:
49429 return NULL;
49430 }
49431
49432
49433 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49434 PyObject *resultobj = 0;
49435 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49436 int arg2 ;
49437 void *argp1 = 0 ;
49438 int res1 = 0 ;
49439 int val2 ;
49440 int ecode2 = 0 ;
49441 PyObject * obj0 = 0 ;
49442 PyObject * obj1 = 0 ;
49443 char * kwnames[] = {
49444 (char *) "self",(char *) "direction", NULL
49445 };
49446
49447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49449 if (!SWIG_IsOK(res1)) {
49450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49451 }
49452 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49453 ecode2 = SWIG_AsVal_int(obj1, &val2);
49454 if (!SWIG_IsOK(ecode2)) {
49455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49456 }
49457 arg2 = static_cast< int >(val2);
49458 {
49459 PyThreadState* __tstate = wxPyBeginAllowThreads();
49460 (arg1)->SetFlexibleDirection(arg2);
49461 wxPyEndAllowThreads(__tstate);
49462 if (PyErr_Occurred()) SWIG_fail;
49463 }
49464 resultobj = SWIG_Py_Void();
49465 return resultobj;
49466 fail:
49467 return NULL;
49468 }
49469
49470
49471 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49472 PyObject *resultobj = 0;
49473 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49474 int result;
49475 void *argp1 = 0 ;
49476 int res1 = 0 ;
49477 PyObject *swig_obj[1] ;
49478
49479 if (!args) SWIG_fail;
49480 swig_obj[0] = args;
49481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49482 if (!SWIG_IsOK(res1)) {
49483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49484 }
49485 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49486 {
49487 PyThreadState* __tstate = wxPyBeginAllowThreads();
49488 result = (int)(arg1)->GetFlexibleDirection();
49489 wxPyEndAllowThreads(__tstate);
49490 if (PyErr_Occurred()) SWIG_fail;
49491 }
49492 resultobj = SWIG_From_int(static_cast< int >(result));
49493 return resultobj;
49494 fail:
49495 return NULL;
49496 }
49497
49498
49499 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49500 PyObject *resultobj = 0;
49501 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49502 wxFlexSizerGrowMode arg2 ;
49503 void *argp1 = 0 ;
49504 int res1 = 0 ;
49505 int val2 ;
49506 int ecode2 = 0 ;
49507 PyObject * obj0 = 0 ;
49508 PyObject * obj1 = 0 ;
49509 char * kwnames[] = {
49510 (char *) "self",(char *) "mode", NULL
49511 };
49512
49513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49515 if (!SWIG_IsOK(res1)) {
49516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49517 }
49518 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49519 ecode2 = SWIG_AsVal_int(obj1, &val2);
49520 if (!SWIG_IsOK(ecode2)) {
49521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49522 }
49523 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49524 {
49525 PyThreadState* __tstate = wxPyBeginAllowThreads();
49526 (arg1)->SetNonFlexibleGrowMode(arg2);
49527 wxPyEndAllowThreads(__tstate);
49528 if (PyErr_Occurred()) SWIG_fail;
49529 }
49530 resultobj = SWIG_Py_Void();
49531 return resultobj;
49532 fail:
49533 return NULL;
49534 }
49535
49536
49537 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49538 PyObject *resultobj = 0;
49539 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49540 wxFlexSizerGrowMode result;
49541 void *argp1 = 0 ;
49542 int res1 = 0 ;
49543 PyObject *swig_obj[1] ;
49544
49545 if (!args) SWIG_fail;
49546 swig_obj[0] = args;
49547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49548 if (!SWIG_IsOK(res1)) {
49549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49550 }
49551 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49555 wxPyEndAllowThreads(__tstate);
49556 if (PyErr_Occurred()) SWIG_fail;
49557 }
49558 resultobj = SWIG_From_int(static_cast< int >(result));
49559 return resultobj;
49560 fail:
49561 return NULL;
49562 }
49563
49564
49565 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49566 PyObject *resultobj = 0;
49567 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49568 wxArrayInt *result = 0 ;
49569 void *argp1 = 0 ;
49570 int res1 = 0 ;
49571 PyObject *swig_obj[1] ;
49572
49573 if (!args) SWIG_fail;
49574 swig_obj[0] = args;
49575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49576 if (!SWIG_IsOK(res1)) {
49577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49578 }
49579 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49580 {
49581 PyThreadState* __tstate = wxPyBeginAllowThreads();
49582 {
49583 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49584 result = (wxArrayInt *) &_result_ref;
49585 }
49586 wxPyEndAllowThreads(__tstate);
49587 if (PyErr_Occurred()) SWIG_fail;
49588 }
49589 {
49590 resultobj = PyList_New(0);
49591 size_t idx;
49592 for (idx = 0; idx < result->GetCount(); idx += 1) {
49593 PyObject* val = PyInt_FromLong( result->Item(idx) );
49594 PyList_Append(resultobj, val);
49595 Py_DECREF(val);
49596 }
49597 }
49598 return resultobj;
49599 fail:
49600 return NULL;
49601 }
49602
49603
49604 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49605 PyObject *resultobj = 0;
49606 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49607 wxArrayInt *result = 0 ;
49608 void *argp1 = 0 ;
49609 int res1 = 0 ;
49610 PyObject *swig_obj[1] ;
49611
49612 if (!args) SWIG_fail;
49613 swig_obj[0] = args;
49614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49615 if (!SWIG_IsOK(res1)) {
49616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49617 }
49618 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49619 {
49620 PyThreadState* __tstate = wxPyBeginAllowThreads();
49621 {
49622 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49623 result = (wxArrayInt *) &_result_ref;
49624 }
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 {
49629 resultobj = PyList_New(0);
49630 size_t idx;
49631 for (idx = 0; idx < result->GetCount(); idx += 1) {
49632 PyObject* val = PyInt_FromLong( result->Item(idx) );
49633 PyList_Append(resultobj, val);
49634 Py_DECREF(val);
49635 }
49636 }
49637 return resultobj;
49638 fail:
49639 return NULL;
49640 }
49641
49642
49643 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49644 PyObject *obj;
49645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49646 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49647 return SWIG_Py_Void();
49648 }
49649
49650 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49651 return SWIG_Python_InitShadowInstance(args);
49652 }
49653
49654 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49655 PyObject *resultobj = 0;
49656 wxStdDialogButtonSizer *result = 0 ;
49657
49658 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49659 {
49660 PyThreadState* __tstate = wxPyBeginAllowThreads();
49661 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49662 wxPyEndAllowThreads(__tstate);
49663 if (PyErr_Occurred()) SWIG_fail;
49664 }
49665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49666 return resultobj;
49667 fail:
49668 return NULL;
49669 }
49670
49671
49672 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49673 PyObject *resultobj = 0;
49674 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49675 wxButton *arg2 = (wxButton *) 0 ;
49676 void *argp1 = 0 ;
49677 int res1 = 0 ;
49678 void *argp2 = 0 ;
49679 int res2 = 0 ;
49680 PyObject * obj0 = 0 ;
49681 PyObject * obj1 = 0 ;
49682 char * kwnames[] = {
49683 (char *) "self",(char *) "button", NULL
49684 };
49685
49686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49688 if (!SWIG_IsOK(res1)) {
49689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49690 }
49691 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49692 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49693 if (!SWIG_IsOK(res2)) {
49694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49695 }
49696 arg2 = reinterpret_cast< wxButton * >(argp2);
49697 {
49698 PyThreadState* __tstate = wxPyBeginAllowThreads();
49699 (arg1)->AddButton(arg2);
49700 wxPyEndAllowThreads(__tstate);
49701 if (PyErr_Occurred()) SWIG_fail;
49702 }
49703 resultobj = SWIG_Py_Void();
49704 return resultobj;
49705 fail:
49706 return NULL;
49707 }
49708
49709
49710 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49711 PyObject *resultobj = 0;
49712 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49713 void *argp1 = 0 ;
49714 int res1 = 0 ;
49715 PyObject *swig_obj[1] ;
49716
49717 if (!args) SWIG_fail;
49718 swig_obj[0] = args;
49719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49720 if (!SWIG_IsOK(res1)) {
49721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49722 }
49723 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49724 {
49725 PyThreadState* __tstate = wxPyBeginAllowThreads();
49726 (arg1)->Realize();
49727 wxPyEndAllowThreads(__tstate);
49728 if (PyErr_Occurred()) SWIG_fail;
49729 }
49730 resultobj = SWIG_Py_Void();
49731 return resultobj;
49732 fail:
49733 return NULL;
49734 }
49735
49736
49737 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49738 PyObject *resultobj = 0;
49739 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49740 wxButton *arg2 = (wxButton *) 0 ;
49741 void *argp1 = 0 ;
49742 int res1 = 0 ;
49743 void *argp2 = 0 ;
49744 int res2 = 0 ;
49745 PyObject * obj0 = 0 ;
49746 PyObject * obj1 = 0 ;
49747 char * kwnames[] = {
49748 (char *) "self",(char *) "button", NULL
49749 };
49750
49751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49753 if (!SWIG_IsOK(res1)) {
49754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49755 }
49756 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49758 if (!SWIG_IsOK(res2)) {
49759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49760 }
49761 arg2 = reinterpret_cast< wxButton * >(argp2);
49762 {
49763 PyThreadState* __tstate = wxPyBeginAllowThreads();
49764 (arg1)->SetAffirmativeButton(arg2);
49765 wxPyEndAllowThreads(__tstate);
49766 if (PyErr_Occurred()) SWIG_fail;
49767 }
49768 resultobj = SWIG_Py_Void();
49769 return resultobj;
49770 fail:
49771 return NULL;
49772 }
49773
49774
49775 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49776 PyObject *resultobj = 0;
49777 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49778 wxButton *arg2 = (wxButton *) 0 ;
49779 void *argp1 = 0 ;
49780 int res1 = 0 ;
49781 void *argp2 = 0 ;
49782 int res2 = 0 ;
49783 PyObject * obj0 = 0 ;
49784 PyObject * obj1 = 0 ;
49785 char * kwnames[] = {
49786 (char *) "self",(char *) "button", NULL
49787 };
49788
49789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49791 if (!SWIG_IsOK(res1)) {
49792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49793 }
49794 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49796 if (!SWIG_IsOK(res2)) {
49797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49798 }
49799 arg2 = reinterpret_cast< wxButton * >(argp2);
49800 {
49801 PyThreadState* __tstate = wxPyBeginAllowThreads();
49802 (arg1)->SetNegativeButton(arg2);
49803 wxPyEndAllowThreads(__tstate);
49804 if (PyErr_Occurred()) SWIG_fail;
49805 }
49806 resultobj = SWIG_Py_Void();
49807 return resultobj;
49808 fail:
49809 return NULL;
49810 }
49811
49812
49813 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49814 PyObject *resultobj = 0;
49815 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49816 wxButton *arg2 = (wxButton *) 0 ;
49817 void *argp1 = 0 ;
49818 int res1 = 0 ;
49819 void *argp2 = 0 ;
49820 int res2 = 0 ;
49821 PyObject * obj0 = 0 ;
49822 PyObject * obj1 = 0 ;
49823 char * kwnames[] = {
49824 (char *) "self",(char *) "button", NULL
49825 };
49826
49827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49829 if (!SWIG_IsOK(res1)) {
49830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49831 }
49832 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49834 if (!SWIG_IsOK(res2)) {
49835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49836 }
49837 arg2 = reinterpret_cast< wxButton * >(argp2);
49838 {
49839 PyThreadState* __tstate = wxPyBeginAllowThreads();
49840 (arg1)->SetCancelButton(arg2);
49841 wxPyEndAllowThreads(__tstate);
49842 if (PyErr_Occurred()) SWIG_fail;
49843 }
49844 resultobj = SWIG_Py_Void();
49845 return resultobj;
49846 fail:
49847 return NULL;
49848 }
49849
49850
49851 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49852 PyObject *resultobj = 0;
49853 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49854 wxButton *result = 0 ;
49855 void *argp1 = 0 ;
49856 int res1 = 0 ;
49857 PyObject *swig_obj[1] ;
49858
49859 if (!args) SWIG_fail;
49860 swig_obj[0] = args;
49861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49862 if (!SWIG_IsOK(res1)) {
49863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49864 }
49865 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49866 {
49867 PyThreadState* __tstate = wxPyBeginAllowThreads();
49868 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49869 wxPyEndAllowThreads(__tstate);
49870 if (PyErr_Occurred()) SWIG_fail;
49871 }
49872 {
49873 resultobj = wxPyMake_wxObject(result, (bool)0);
49874 }
49875 return resultobj;
49876 fail:
49877 return NULL;
49878 }
49879
49880
49881 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49882 PyObject *resultobj = 0;
49883 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49884 wxButton *result = 0 ;
49885 void *argp1 = 0 ;
49886 int res1 = 0 ;
49887 PyObject *swig_obj[1] ;
49888
49889 if (!args) SWIG_fail;
49890 swig_obj[0] = args;
49891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49892 if (!SWIG_IsOK(res1)) {
49893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49894 }
49895 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49896 {
49897 PyThreadState* __tstate = wxPyBeginAllowThreads();
49898 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49899 wxPyEndAllowThreads(__tstate);
49900 if (PyErr_Occurred()) SWIG_fail;
49901 }
49902 {
49903 resultobj = wxPyMake_wxObject(result, (bool)0);
49904 }
49905 return resultobj;
49906 fail:
49907 return NULL;
49908 }
49909
49910
49911 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49912 PyObject *resultobj = 0;
49913 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49914 wxButton *result = 0 ;
49915 void *argp1 = 0 ;
49916 int res1 = 0 ;
49917 PyObject *swig_obj[1] ;
49918
49919 if (!args) SWIG_fail;
49920 swig_obj[0] = args;
49921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49922 if (!SWIG_IsOK(res1)) {
49923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49924 }
49925 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49926 {
49927 PyThreadState* __tstate = wxPyBeginAllowThreads();
49928 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49929 wxPyEndAllowThreads(__tstate);
49930 if (PyErr_Occurred()) SWIG_fail;
49931 }
49932 {
49933 resultobj = wxPyMake_wxObject(result, (bool)0);
49934 }
49935 return resultobj;
49936 fail:
49937 return NULL;
49938 }
49939
49940
49941 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49942 PyObject *resultobj = 0;
49943 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49944 wxButton *result = 0 ;
49945 void *argp1 = 0 ;
49946 int res1 = 0 ;
49947 PyObject *swig_obj[1] ;
49948
49949 if (!args) SWIG_fail;
49950 swig_obj[0] = args;
49951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49952 if (!SWIG_IsOK(res1)) {
49953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49954 }
49955 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49956 {
49957 PyThreadState* __tstate = wxPyBeginAllowThreads();
49958 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49959 wxPyEndAllowThreads(__tstate);
49960 if (PyErr_Occurred()) SWIG_fail;
49961 }
49962 {
49963 resultobj = wxPyMake_wxObject(result, (bool)0);
49964 }
49965 return resultobj;
49966 fail:
49967 return NULL;
49968 }
49969
49970
49971 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49972 PyObject *resultobj = 0;
49973 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49974 wxButton *result = 0 ;
49975 void *argp1 = 0 ;
49976 int res1 = 0 ;
49977 PyObject *swig_obj[1] ;
49978
49979 if (!args) SWIG_fail;
49980 swig_obj[0] = args;
49981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49982 if (!SWIG_IsOK(res1)) {
49983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49984 }
49985 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49986 {
49987 PyThreadState* __tstate = wxPyBeginAllowThreads();
49988 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49989 wxPyEndAllowThreads(__tstate);
49990 if (PyErr_Occurred()) SWIG_fail;
49991 }
49992 {
49993 resultobj = wxPyMake_wxObject(result, (bool)0);
49994 }
49995 return resultobj;
49996 fail:
49997 return NULL;
49998 }
49999
50000
50001 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50002 PyObject *obj;
50003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50004 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50005 return SWIG_Py_Void();
50006 }
50007
50008 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50009 return SWIG_Python_InitShadowInstance(args);
50010 }
50011
50012 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50013 PyObject *resultobj = 0;
50014 int arg1 = (int) 0 ;
50015 int arg2 = (int) 0 ;
50016 wxGBPosition *result = 0 ;
50017 int val1 ;
50018 int ecode1 = 0 ;
50019 int val2 ;
50020 int ecode2 = 0 ;
50021 PyObject * obj0 = 0 ;
50022 PyObject * obj1 = 0 ;
50023 char * kwnames[] = {
50024 (char *) "row",(char *) "col", NULL
50025 };
50026
50027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50028 if (obj0) {
50029 ecode1 = SWIG_AsVal_int(obj0, &val1);
50030 if (!SWIG_IsOK(ecode1)) {
50031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50032 }
50033 arg1 = static_cast< int >(val1);
50034 }
50035 if (obj1) {
50036 ecode2 = SWIG_AsVal_int(obj1, &val2);
50037 if (!SWIG_IsOK(ecode2)) {
50038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50039 }
50040 arg2 = static_cast< int >(val2);
50041 }
50042 {
50043 PyThreadState* __tstate = wxPyBeginAllowThreads();
50044 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50045 wxPyEndAllowThreads(__tstate);
50046 if (PyErr_Occurred()) SWIG_fail;
50047 }
50048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50049 return resultobj;
50050 fail:
50051 return NULL;
50052 }
50053
50054
50055 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50056 PyObject *resultobj = 0;
50057 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50058 void *argp1 = 0 ;
50059 int res1 = 0 ;
50060 PyObject *swig_obj[1] ;
50061
50062 if (!args) SWIG_fail;
50063 swig_obj[0] = args;
50064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50065 if (!SWIG_IsOK(res1)) {
50066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50067 }
50068 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50069 {
50070 PyThreadState* __tstate = wxPyBeginAllowThreads();
50071 delete arg1;
50072
50073 wxPyEndAllowThreads(__tstate);
50074 if (PyErr_Occurred()) SWIG_fail;
50075 }
50076 resultobj = SWIG_Py_Void();
50077 return resultobj;
50078 fail:
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50084 PyObject *resultobj = 0;
50085 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50086 int result;
50087 void *argp1 = 0 ;
50088 int res1 = 0 ;
50089 PyObject *swig_obj[1] ;
50090
50091 if (!args) SWIG_fail;
50092 swig_obj[0] = args;
50093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50094 if (!SWIG_IsOK(res1)) {
50095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50096 }
50097 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50098 {
50099 PyThreadState* __tstate = wxPyBeginAllowThreads();
50100 result = (int)((wxGBPosition const *)arg1)->GetRow();
50101 wxPyEndAllowThreads(__tstate);
50102 if (PyErr_Occurred()) SWIG_fail;
50103 }
50104 resultobj = SWIG_From_int(static_cast< int >(result));
50105 return resultobj;
50106 fail:
50107 return NULL;
50108 }
50109
50110
50111 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50112 PyObject *resultobj = 0;
50113 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50114 int result;
50115 void *argp1 = 0 ;
50116 int res1 = 0 ;
50117 PyObject *swig_obj[1] ;
50118
50119 if (!args) SWIG_fail;
50120 swig_obj[0] = args;
50121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50122 if (!SWIG_IsOK(res1)) {
50123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50124 }
50125 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50126 {
50127 PyThreadState* __tstate = wxPyBeginAllowThreads();
50128 result = (int)((wxGBPosition const *)arg1)->GetCol();
50129 wxPyEndAllowThreads(__tstate);
50130 if (PyErr_Occurred()) SWIG_fail;
50131 }
50132 resultobj = SWIG_From_int(static_cast< int >(result));
50133 return resultobj;
50134 fail:
50135 return NULL;
50136 }
50137
50138
50139 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50140 PyObject *resultobj = 0;
50141 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50142 int arg2 ;
50143 void *argp1 = 0 ;
50144 int res1 = 0 ;
50145 int val2 ;
50146 int ecode2 = 0 ;
50147 PyObject * obj0 = 0 ;
50148 PyObject * obj1 = 0 ;
50149 char * kwnames[] = {
50150 (char *) "self",(char *) "row", NULL
50151 };
50152
50153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50155 if (!SWIG_IsOK(res1)) {
50156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50157 }
50158 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50159 ecode2 = SWIG_AsVal_int(obj1, &val2);
50160 if (!SWIG_IsOK(ecode2)) {
50161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50162 }
50163 arg2 = static_cast< int >(val2);
50164 {
50165 PyThreadState* __tstate = wxPyBeginAllowThreads();
50166 (arg1)->SetRow(arg2);
50167 wxPyEndAllowThreads(__tstate);
50168 if (PyErr_Occurred()) SWIG_fail;
50169 }
50170 resultobj = SWIG_Py_Void();
50171 return resultobj;
50172 fail:
50173 return NULL;
50174 }
50175
50176
50177 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50178 PyObject *resultobj = 0;
50179 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50180 int arg2 ;
50181 void *argp1 = 0 ;
50182 int res1 = 0 ;
50183 int val2 ;
50184 int ecode2 = 0 ;
50185 PyObject * obj0 = 0 ;
50186 PyObject * obj1 = 0 ;
50187 char * kwnames[] = {
50188 (char *) "self",(char *) "col", NULL
50189 };
50190
50191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50193 if (!SWIG_IsOK(res1)) {
50194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50195 }
50196 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50197 ecode2 = SWIG_AsVal_int(obj1, &val2);
50198 if (!SWIG_IsOK(ecode2)) {
50199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50200 }
50201 arg2 = static_cast< int >(val2);
50202 {
50203 PyThreadState* __tstate = wxPyBeginAllowThreads();
50204 (arg1)->SetCol(arg2);
50205 wxPyEndAllowThreads(__tstate);
50206 if (PyErr_Occurred()) SWIG_fail;
50207 }
50208 resultobj = SWIG_Py_Void();
50209 return resultobj;
50210 fail:
50211 return NULL;
50212 }
50213
50214
50215 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50216 PyObject *resultobj = 0;
50217 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50218 PyObject *arg2 = (PyObject *) 0 ;
50219 bool result;
50220 void *argp1 = 0 ;
50221 int res1 = 0 ;
50222 PyObject * obj0 = 0 ;
50223 PyObject * obj1 = 0 ;
50224 char * kwnames[] = {
50225 (char *) "self",(char *) "other", NULL
50226 };
50227
50228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50230 if (!SWIG_IsOK(res1)) {
50231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50232 }
50233 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50234 arg2 = obj1;
50235 {
50236 result = (bool)wxGBPosition___eq__(arg1,arg2);
50237 if (PyErr_Occurred()) SWIG_fail;
50238 }
50239 {
50240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50241 }
50242 return resultobj;
50243 fail:
50244 return NULL;
50245 }
50246
50247
50248 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50249 PyObject *resultobj = 0;
50250 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50251 PyObject *arg2 = (PyObject *) 0 ;
50252 bool result;
50253 void *argp1 = 0 ;
50254 int res1 = 0 ;
50255 PyObject * obj0 = 0 ;
50256 PyObject * obj1 = 0 ;
50257 char * kwnames[] = {
50258 (char *) "self",(char *) "other", NULL
50259 };
50260
50261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50263 if (!SWIG_IsOK(res1)) {
50264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50265 }
50266 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50267 arg2 = obj1;
50268 {
50269 result = (bool)wxGBPosition___ne__(arg1,arg2);
50270 if (PyErr_Occurred()) SWIG_fail;
50271 }
50272 {
50273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50274 }
50275 return resultobj;
50276 fail:
50277 return NULL;
50278 }
50279
50280
50281 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50282 PyObject *resultobj = 0;
50283 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50284 int arg2 = (int) 0 ;
50285 int arg3 = (int) 0 ;
50286 void *argp1 = 0 ;
50287 int res1 = 0 ;
50288 int val2 ;
50289 int ecode2 = 0 ;
50290 int val3 ;
50291 int ecode3 = 0 ;
50292 PyObject * obj0 = 0 ;
50293 PyObject * obj1 = 0 ;
50294 PyObject * obj2 = 0 ;
50295 char * kwnames[] = {
50296 (char *) "self",(char *) "row",(char *) "col", NULL
50297 };
50298
50299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50301 if (!SWIG_IsOK(res1)) {
50302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50303 }
50304 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50305 if (obj1) {
50306 ecode2 = SWIG_AsVal_int(obj1, &val2);
50307 if (!SWIG_IsOK(ecode2)) {
50308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50309 }
50310 arg2 = static_cast< int >(val2);
50311 }
50312 if (obj2) {
50313 ecode3 = SWIG_AsVal_int(obj2, &val3);
50314 if (!SWIG_IsOK(ecode3)) {
50315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50316 }
50317 arg3 = static_cast< int >(val3);
50318 }
50319 {
50320 PyThreadState* __tstate = wxPyBeginAllowThreads();
50321 wxGBPosition_Set(arg1,arg2,arg3);
50322 wxPyEndAllowThreads(__tstate);
50323 if (PyErr_Occurred()) SWIG_fail;
50324 }
50325 resultobj = SWIG_Py_Void();
50326 return resultobj;
50327 fail:
50328 return NULL;
50329 }
50330
50331
50332 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50333 PyObject *resultobj = 0;
50334 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50335 PyObject *result = 0 ;
50336 void *argp1 = 0 ;
50337 int res1 = 0 ;
50338 PyObject *swig_obj[1] ;
50339
50340 if (!args) SWIG_fail;
50341 swig_obj[0] = args;
50342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50343 if (!SWIG_IsOK(res1)) {
50344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50345 }
50346 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50347 {
50348 PyThreadState* __tstate = wxPyBeginAllowThreads();
50349 result = (PyObject *)wxGBPosition_Get(arg1);
50350 wxPyEndAllowThreads(__tstate);
50351 if (PyErr_Occurred()) SWIG_fail;
50352 }
50353 resultobj = result;
50354 return resultobj;
50355 fail:
50356 return NULL;
50357 }
50358
50359
50360 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50361 PyObject *obj;
50362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50363 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50364 return SWIG_Py_Void();
50365 }
50366
50367 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50368 return SWIG_Python_InitShadowInstance(args);
50369 }
50370
50371 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50372 PyObject *resultobj = 0;
50373 int arg1 = (int) 1 ;
50374 int arg2 = (int) 1 ;
50375 wxGBSpan *result = 0 ;
50376 int val1 ;
50377 int ecode1 = 0 ;
50378 int val2 ;
50379 int ecode2 = 0 ;
50380 PyObject * obj0 = 0 ;
50381 PyObject * obj1 = 0 ;
50382 char * kwnames[] = {
50383 (char *) "rowspan",(char *) "colspan", NULL
50384 };
50385
50386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50387 if (obj0) {
50388 ecode1 = SWIG_AsVal_int(obj0, &val1);
50389 if (!SWIG_IsOK(ecode1)) {
50390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50391 }
50392 arg1 = static_cast< int >(val1);
50393 }
50394 if (obj1) {
50395 ecode2 = SWIG_AsVal_int(obj1, &val2);
50396 if (!SWIG_IsOK(ecode2)) {
50397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50398 }
50399 arg2 = static_cast< int >(val2);
50400 }
50401 {
50402 PyThreadState* __tstate = wxPyBeginAllowThreads();
50403 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50404 wxPyEndAllowThreads(__tstate);
50405 if (PyErr_Occurred()) SWIG_fail;
50406 }
50407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50408 return resultobj;
50409 fail:
50410 return NULL;
50411 }
50412
50413
50414 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50415 PyObject *resultobj = 0;
50416 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50417 void *argp1 = 0 ;
50418 int res1 = 0 ;
50419 PyObject *swig_obj[1] ;
50420
50421 if (!args) SWIG_fail;
50422 swig_obj[0] = args;
50423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50424 if (!SWIG_IsOK(res1)) {
50425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50426 }
50427 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50428 {
50429 PyThreadState* __tstate = wxPyBeginAllowThreads();
50430 delete arg1;
50431
50432 wxPyEndAllowThreads(__tstate);
50433 if (PyErr_Occurred()) SWIG_fail;
50434 }
50435 resultobj = SWIG_Py_Void();
50436 return resultobj;
50437 fail:
50438 return NULL;
50439 }
50440
50441
50442 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50443 PyObject *resultobj = 0;
50444 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50445 int result;
50446 void *argp1 = 0 ;
50447 int res1 = 0 ;
50448 PyObject *swig_obj[1] ;
50449
50450 if (!args) SWIG_fail;
50451 swig_obj[0] = args;
50452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50453 if (!SWIG_IsOK(res1)) {
50454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50455 }
50456 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50457 {
50458 PyThreadState* __tstate = wxPyBeginAllowThreads();
50459 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50460 wxPyEndAllowThreads(__tstate);
50461 if (PyErr_Occurred()) SWIG_fail;
50462 }
50463 resultobj = SWIG_From_int(static_cast< int >(result));
50464 return resultobj;
50465 fail:
50466 return NULL;
50467 }
50468
50469
50470 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50471 PyObject *resultobj = 0;
50472 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50473 int result;
50474 void *argp1 = 0 ;
50475 int res1 = 0 ;
50476 PyObject *swig_obj[1] ;
50477
50478 if (!args) SWIG_fail;
50479 swig_obj[0] = args;
50480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50481 if (!SWIG_IsOK(res1)) {
50482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50483 }
50484 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50485 {
50486 PyThreadState* __tstate = wxPyBeginAllowThreads();
50487 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50488 wxPyEndAllowThreads(__tstate);
50489 if (PyErr_Occurred()) SWIG_fail;
50490 }
50491 resultobj = SWIG_From_int(static_cast< int >(result));
50492 return resultobj;
50493 fail:
50494 return NULL;
50495 }
50496
50497
50498 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50499 PyObject *resultobj = 0;
50500 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50501 int arg2 ;
50502 void *argp1 = 0 ;
50503 int res1 = 0 ;
50504 int val2 ;
50505 int ecode2 = 0 ;
50506 PyObject * obj0 = 0 ;
50507 PyObject * obj1 = 0 ;
50508 char * kwnames[] = {
50509 (char *) "self",(char *) "rowspan", NULL
50510 };
50511
50512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50514 if (!SWIG_IsOK(res1)) {
50515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50516 }
50517 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50518 ecode2 = SWIG_AsVal_int(obj1, &val2);
50519 if (!SWIG_IsOK(ecode2)) {
50520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50521 }
50522 arg2 = static_cast< int >(val2);
50523 {
50524 PyThreadState* __tstate = wxPyBeginAllowThreads();
50525 (arg1)->SetRowspan(arg2);
50526 wxPyEndAllowThreads(__tstate);
50527 if (PyErr_Occurred()) SWIG_fail;
50528 }
50529 resultobj = SWIG_Py_Void();
50530 return resultobj;
50531 fail:
50532 return NULL;
50533 }
50534
50535
50536 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50537 PyObject *resultobj = 0;
50538 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50539 int arg2 ;
50540 void *argp1 = 0 ;
50541 int res1 = 0 ;
50542 int val2 ;
50543 int ecode2 = 0 ;
50544 PyObject * obj0 = 0 ;
50545 PyObject * obj1 = 0 ;
50546 char * kwnames[] = {
50547 (char *) "self",(char *) "colspan", NULL
50548 };
50549
50550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50552 if (!SWIG_IsOK(res1)) {
50553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50554 }
50555 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50556 ecode2 = SWIG_AsVal_int(obj1, &val2);
50557 if (!SWIG_IsOK(ecode2)) {
50558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50559 }
50560 arg2 = static_cast< int >(val2);
50561 {
50562 PyThreadState* __tstate = wxPyBeginAllowThreads();
50563 (arg1)->SetColspan(arg2);
50564 wxPyEndAllowThreads(__tstate);
50565 if (PyErr_Occurred()) SWIG_fail;
50566 }
50567 resultobj = SWIG_Py_Void();
50568 return resultobj;
50569 fail:
50570 return NULL;
50571 }
50572
50573
50574 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50575 PyObject *resultobj = 0;
50576 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50577 PyObject *arg2 = (PyObject *) 0 ;
50578 bool result;
50579 void *argp1 = 0 ;
50580 int res1 = 0 ;
50581 PyObject * obj0 = 0 ;
50582 PyObject * obj1 = 0 ;
50583 char * kwnames[] = {
50584 (char *) "self",(char *) "other", NULL
50585 };
50586
50587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50589 if (!SWIG_IsOK(res1)) {
50590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50591 }
50592 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50593 arg2 = obj1;
50594 {
50595 result = (bool)wxGBSpan___eq__(arg1,arg2);
50596 if (PyErr_Occurred()) SWIG_fail;
50597 }
50598 {
50599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50600 }
50601 return resultobj;
50602 fail:
50603 return NULL;
50604 }
50605
50606
50607 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50608 PyObject *resultobj = 0;
50609 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50610 PyObject *arg2 = (PyObject *) 0 ;
50611 bool result;
50612 void *argp1 = 0 ;
50613 int res1 = 0 ;
50614 PyObject * obj0 = 0 ;
50615 PyObject * obj1 = 0 ;
50616 char * kwnames[] = {
50617 (char *) "self",(char *) "other", NULL
50618 };
50619
50620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50622 if (!SWIG_IsOK(res1)) {
50623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50624 }
50625 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50626 arg2 = obj1;
50627 {
50628 result = (bool)wxGBSpan___ne__(arg1,arg2);
50629 if (PyErr_Occurred()) SWIG_fail;
50630 }
50631 {
50632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50633 }
50634 return resultobj;
50635 fail:
50636 return NULL;
50637 }
50638
50639
50640 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50641 PyObject *resultobj = 0;
50642 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50643 int arg2 = (int) 1 ;
50644 int arg3 = (int) 1 ;
50645 void *argp1 = 0 ;
50646 int res1 = 0 ;
50647 int val2 ;
50648 int ecode2 = 0 ;
50649 int val3 ;
50650 int ecode3 = 0 ;
50651 PyObject * obj0 = 0 ;
50652 PyObject * obj1 = 0 ;
50653 PyObject * obj2 = 0 ;
50654 char * kwnames[] = {
50655 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50656 };
50657
50658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50660 if (!SWIG_IsOK(res1)) {
50661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50662 }
50663 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50664 if (obj1) {
50665 ecode2 = SWIG_AsVal_int(obj1, &val2);
50666 if (!SWIG_IsOK(ecode2)) {
50667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50668 }
50669 arg2 = static_cast< int >(val2);
50670 }
50671 if (obj2) {
50672 ecode3 = SWIG_AsVal_int(obj2, &val3);
50673 if (!SWIG_IsOK(ecode3)) {
50674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50675 }
50676 arg3 = static_cast< int >(val3);
50677 }
50678 {
50679 PyThreadState* __tstate = wxPyBeginAllowThreads();
50680 wxGBSpan_Set(arg1,arg2,arg3);
50681 wxPyEndAllowThreads(__tstate);
50682 if (PyErr_Occurred()) SWIG_fail;
50683 }
50684 resultobj = SWIG_Py_Void();
50685 return resultobj;
50686 fail:
50687 return NULL;
50688 }
50689
50690
50691 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50692 PyObject *resultobj = 0;
50693 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50694 PyObject *result = 0 ;
50695 void *argp1 = 0 ;
50696 int res1 = 0 ;
50697 PyObject *swig_obj[1] ;
50698
50699 if (!args) SWIG_fail;
50700 swig_obj[0] = args;
50701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50702 if (!SWIG_IsOK(res1)) {
50703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50704 }
50705 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50706 {
50707 PyThreadState* __tstate = wxPyBeginAllowThreads();
50708 result = (PyObject *)wxGBSpan_Get(arg1);
50709 wxPyEndAllowThreads(__tstate);
50710 if (PyErr_Occurred()) SWIG_fail;
50711 }
50712 resultobj = result;
50713 return resultobj;
50714 fail:
50715 return NULL;
50716 }
50717
50718
50719 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50720 PyObject *obj;
50721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50722 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50723 return SWIG_Py_Void();
50724 }
50725
50726 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50727 return SWIG_Python_InitShadowInstance(args);
50728 }
50729
50730 SWIGINTERN int DefaultSpan_set(PyObject *) {
50731 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50732 return 1;
50733 }
50734
50735
50736 SWIGINTERN PyObject *DefaultSpan_get(void) {
50737 PyObject *pyobj = 0;
50738
50739 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50740 return pyobj;
50741 }
50742
50743
50744 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50745 PyObject *resultobj = 0;
50746 wxGBSizerItem *result = 0 ;
50747
50748 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50749 {
50750 PyThreadState* __tstate = wxPyBeginAllowThreads();
50751 result = (wxGBSizerItem *)new wxGBSizerItem();
50752 wxPyEndAllowThreads(__tstate);
50753 if (PyErr_Occurred()) SWIG_fail;
50754 }
50755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50756 return resultobj;
50757 fail:
50758 return NULL;
50759 }
50760
50761
50762 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50763 PyObject *resultobj = 0;
50764 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50765 void *argp1 = 0 ;
50766 int res1 = 0 ;
50767 PyObject *swig_obj[1] ;
50768
50769 if (!args) SWIG_fail;
50770 swig_obj[0] = args;
50771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50772 if (!SWIG_IsOK(res1)) {
50773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50774 }
50775 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50776 {
50777 PyThreadState* __tstate = wxPyBeginAllowThreads();
50778 delete arg1;
50779
50780 wxPyEndAllowThreads(__tstate);
50781 if (PyErr_Occurred()) SWIG_fail;
50782 }
50783 resultobj = SWIG_Py_Void();
50784 return resultobj;
50785 fail:
50786 return NULL;
50787 }
50788
50789
50790 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50791 PyObject *resultobj = 0;
50792 wxWindow *arg1 = (wxWindow *) 0 ;
50793 wxGBPosition *arg2 = 0 ;
50794 wxGBSpan *arg3 = 0 ;
50795 int arg4 ;
50796 int arg5 ;
50797 PyObject *arg6 = (PyObject *) NULL ;
50798 wxGBSizerItem *result = 0 ;
50799 void *argp1 = 0 ;
50800 int res1 = 0 ;
50801 wxGBPosition temp2 ;
50802 wxGBSpan temp3 ;
50803 int val4 ;
50804 int ecode4 = 0 ;
50805 int val5 ;
50806 int ecode5 = 0 ;
50807 PyObject * obj0 = 0 ;
50808 PyObject * obj1 = 0 ;
50809 PyObject * obj2 = 0 ;
50810 PyObject * obj3 = 0 ;
50811 PyObject * obj4 = 0 ;
50812 PyObject * obj5 = 0 ;
50813 char * kwnames[] = {
50814 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50815 };
50816
50817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50819 if (!SWIG_IsOK(res1)) {
50820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50821 }
50822 arg1 = reinterpret_cast< wxWindow * >(argp1);
50823 {
50824 arg2 = &temp2;
50825 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50826 }
50827 {
50828 arg3 = &temp3;
50829 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50830 }
50831 ecode4 = SWIG_AsVal_int(obj3, &val4);
50832 if (!SWIG_IsOK(ecode4)) {
50833 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50834 }
50835 arg4 = static_cast< int >(val4);
50836 ecode5 = SWIG_AsVal_int(obj4, &val5);
50837 if (!SWIG_IsOK(ecode5)) {
50838 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50839 }
50840 arg5 = static_cast< int >(val5);
50841 if (obj5) {
50842 arg6 = obj5;
50843 }
50844 {
50845 PyThreadState* __tstate = wxPyBeginAllowThreads();
50846 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50847 wxPyEndAllowThreads(__tstate);
50848 if (PyErr_Occurred()) SWIG_fail;
50849 }
50850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50851 return resultobj;
50852 fail:
50853 return NULL;
50854 }
50855
50856
50857 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50858 PyObject *resultobj = 0;
50859 wxSizer *arg1 = (wxSizer *) 0 ;
50860 wxGBPosition *arg2 = 0 ;
50861 wxGBSpan *arg3 = 0 ;
50862 int arg4 ;
50863 int arg5 ;
50864 PyObject *arg6 = (PyObject *) NULL ;
50865 wxGBSizerItem *result = 0 ;
50866 int res1 = 0 ;
50867 wxGBPosition temp2 ;
50868 wxGBSpan temp3 ;
50869 int val4 ;
50870 int ecode4 = 0 ;
50871 int val5 ;
50872 int ecode5 = 0 ;
50873 PyObject * obj0 = 0 ;
50874 PyObject * obj1 = 0 ;
50875 PyObject * obj2 = 0 ;
50876 PyObject * obj3 = 0 ;
50877 PyObject * obj4 = 0 ;
50878 PyObject * obj5 = 0 ;
50879 char * kwnames[] = {
50880 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50881 };
50882
50883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50884 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50885 if (!SWIG_IsOK(res1)) {
50886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50887 }
50888 {
50889 arg2 = &temp2;
50890 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50891 }
50892 {
50893 arg3 = &temp3;
50894 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50895 }
50896 ecode4 = SWIG_AsVal_int(obj3, &val4);
50897 if (!SWIG_IsOK(ecode4)) {
50898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50899 }
50900 arg4 = static_cast< int >(val4);
50901 ecode5 = SWIG_AsVal_int(obj4, &val5);
50902 if (!SWIG_IsOK(ecode5)) {
50903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50904 }
50905 arg5 = static_cast< int >(val5);
50906 if (obj5) {
50907 arg6 = obj5;
50908 }
50909 {
50910 PyThreadState* __tstate = wxPyBeginAllowThreads();
50911 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50912 wxPyEndAllowThreads(__tstate);
50913 if (PyErr_Occurred()) SWIG_fail;
50914 }
50915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50916 return resultobj;
50917 fail:
50918 return NULL;
50919 }
50920
50921
50922 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50923 PyObject *resultobj = 0;
50924 int arg1 ;
50925 int arg2 ;
50926 wxGBPosition *arg3 = 0 ;
50927 wxGBSpan *arg4 = 0 ;
50928 int arg5 ;
50929 int arg6 ;
50930 PyObject *arg7 = (PyObject *) NULL ;
50931 wxGBSizerItem *result = 0 ;
50932 int val1 ;
50933 int ecode1 = 0 ;
50934 int val2 ;
50935 int ecode2 = 0 ;
50936 wxGBPosition temp3 ;
50937 wxGBSpan temp4 ;
50938 int val5 ;
50939 int ecode5 = 0 ;
50940 int val6 ;
50941 int ecode6 = 0 ;
50942 PyObject * obj0 = 0 ;
50943 PyObject * obj1 = 0 ;
50944 PyObject * obj2 = 0 ;
50945 PyObject * obj3 = 0 ;
50946 PyObject * obj4 = 0 ;
50947 PyObject * obj5 = 0 ;
50948 PyObject * obj6 = 0 ;
50949 char * kwnames[] = {
50950 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50951 };
50952
50953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50954 ecode1 = SWIG_AsVal_int(obj0, &val1);
50955 if (!SWIG_IsOK(ecode1)) {
50956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50957 }
50958 arg1 = static_cast< int >(val1);
50959 ecode2 = SWIG_AsVal_int(obj1, &val2);
50960 if (!SWIG_IsOK(ecode2)) {
50961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50962 }
50963 arg2 = static_cast< int >(val2);
50964 {
50965 arg3 = &temp3;
50966 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50967 }
50968 {
50969 arg4 = &temp4;
50970 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50971 }
50972 ecode5 = SWIG_AsVal_int(obj4, &val5);
50973 if (!SWIG_IsOK(ecode5)) {
50974 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50975 }
50976 arg5 = static_cast< int >(val5);
50977 ecode6 = SWIG_AsVal_int(obj5, &val6);
50978 if (!SWIG_IsOK(ecode6)) {
50979 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50980 }
50981 arg6 = static_cast< int >(val6);
50982 if (obj6) {
50983 arg7 = obj6;
50984 }
50985 {
50986 PyThreadState* __tstate = wxPyBeginAllowThreads();
50987 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50988 wxPyEndAllowThreads(__tstate);
50989 if (PyErr_Occurred()) SWIG_fail;
50990 }
50991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50992 return resultobj;
50993 fail:
50994 return NULL;
50995 }
50996
50997
50998 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50999 PyObject *resultobj = 0;
51000 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51001 wxGBPosition result;
51002 void *argp1 = 0 ;
51003 int res1 = 0 ;
51004 PyObject *swig_obj[1] ;
51005
51006 if (!args) SWIG_fail;
51007 swig_obj[0] = args;
51008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51009 if (!SWIG_IsOK(res1)) {
51010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51011 }
51012 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51013 {
51014 PyThreadState* __tstate = wxPyBeginAllowThreads();
51015 result = ((wxGBSizerItem const *)arg1)->GetPos();
51016 wxPyEndAllowThreads(__tstate);
51017 if (PyErr_Occurred()) SWIG_fail;
51018 }
51019 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51020 return resultobj;
51021 fail:
51022 return NULL;
51023 }
51024
51025
51026 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51027 PyObject *resultobj = 0;
51028 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51029 wxGBSpan result;
51030 void *argp1 = 0 ;
51031 int res1 = 0 ;
51032 PyObject *swig_obj[1] ;
51033
51034 if (!args) SWIG_fail;
51035 swig_obj[0] = args;
51036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51037 if (!SWIG_IsOK(res1)) {
51038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51039 }
51040 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51041 {
51042 PyThreadState* __tstate = wxPyBeginAllowThreads();
51043 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51044 wxPyEndAllowThreads(__tstate);
51045 if (PyErr_Occurred()) SWIG_fail;
51046 }
51047 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51048 return resultobj;
51049 fail:
51050 return NULL;
51051 }
51052
51053
51054 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51055 PyObject *resultobj = 0;
51056 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51057 wxGBPosition *arg2 = 0 ;
51058 bool result;
51059 void *argp1 = 0 ;
51060 int res1 = 0 ;
51061 wxGBPosition temp2 ;
51062 PyObject * obj0 = 0 ;
51063 PyObject * obj1 = 0 ;
51064 char * kwnames[] = {
51065 (char *) "self",(char *) "pos", NULL
51066 };
51067
51068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51070 if (!SWIG_IsOK(res1)) {
51071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51072 }
51073 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51074 {
51075 arg2 = &temp2;
51076 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51077 }
51078 {
51079 PyThreadState* __tstate = wxPyBeginAllowThreads();
51080 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51081 wxPyEndAllowThreads(__tstate);
51082 if (PyErr_Occurred()) SWIG_fail;
51083 }
51084 {
51085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51086 }
51087 return resultobj;
51088 fail:
51089 return NULL;
51090 }
51091
51092
51093 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51094 PyObject *resultobj = 0;
51095 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51096 wxGBSpan *arg2 = 0 ;
51097 bool result;
51098 void *argp1 = 0 ;
51099 int res1 = 0 ;
51100 wxGBSpan temp2 ;
51101 PyObject * obj0 = 0 ;
51102 PyObject * obj1 = 0 ;
51103 char * kwnames[] = {
51104 (char *) "self",(char *) "span", NULL
51105 };
51106
51107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51109 if (!SWIG_IsOK(res1)) {
51110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51111 }
51112 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51113 {
51114 arg2 = &temp2;
51115 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51116 }
51117 {
51118 PyThreadState* __tstate = wxPyBeginAllowThreads();
51119 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51120 wxPyEndAllowThreads(__tstate);
51121 if (PyErr_Occurred()) SWIG_fail;
51122 }
51123 {
51124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51125 }
51126 return resultobj;
51127 fail:
51128 return NULL;
51129 }
51130
51131
51132 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51133 PyObject *resultobj = 0;
51134 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51135 wxGBSizerItem *arg2 = 0 ;
51136 bool result;
51137 void *argp1 = 0 ;
51138 int res1 = 0 ;
51139 void *argp2 = 0 ;
51140 int res2 = 0 ;
51141 PyObject * obj0 = 0 ;
51142 PyObject * obj1 = 0 ;
51143 char * kwnames[] = {
51144 (char *) "self",(char *) "other", NULL
51145 };
51146
51147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51149 if (!SWIG_IsOK(res1)) {
51150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51151 }
51152 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51154 if (!SWIG_IsOK(res2)) {
51155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51156 }
51157 if (!argp2) {
51158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51159 }
51160 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51161 {
51162 PyThreadState* __tstate = wxPyBeginAllowThreads();
51163 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51164 wxPyEndAllowThreads(__tstate);
51165 if (PyErr_Occurred()) SWIG_fail;
51166 }
51167 {
51168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51169 }
51170 return resultobj;
51171 fail:
51172 return NULL;
51173 }
51174
51175
51176 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51177 PyObject *resultobj = 0;
51178 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51179 wxGBPosition *arg2 = 0 ;
51180 wxGBSpan *arg3 = 0 ;
51181 bool result;
51182 void *argp1 = 0 ;
51183 int res1 = 0 ;
51184 wxGBPosition temp2 ;
51185 wxGBSpan temp3 ;
51186 PyObject * obj0 = 0 ;
51187 PyObject * obj1 = 0 ;
51188 PyObject * obj2 = 0 ;
51189 char * kwnames[] = {
51190 (char *) "self",(char *) "pos",(char *) "span", NULL
51191 };
51192
51193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51195 if (!SWIG_IsOK(res1)) {
51196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51197 }
51198 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51199 {
51200 arg2 = &temp2;
51201 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51202 }
51203 {
51204 arg3 = &temp3;
51205 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51206 }
51207 {
51208 PyThreadState* __tstate = wxPyBeginAllowThreads();
51209 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51210 wxPyEndAllowThreads(__tstate);
51211 if (PyErr_Occurred()) SWIG_fail;
51212 }
51213 {
51214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51215 }
51216 return resultobj;
51217 fail:
51218 return NULL;
51219 }
51220
51221
51222 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51223 PyObject *resultobj = 0;
51224 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51225 wxGBPosition result;
51226 void *argp1 = 0 ;
51227 int res1 = 0 ;
51228 PyObject *swig_obj[1] ;
51229
51230 if (!args) SWIG_fail;
51231 swig_obj[0] = args;
51232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51233 if (!SWIG_IsOK(res1)) {
51234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51235 }
51236 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51237 {
51238 PyThreadState* __tstate = wxPyBeginAllowThreads();
51239 result = wxGBSizerItem_GetEndPos(arg1);
51240 wxPyEndAllowThreads(__tstate);
51241 if (PyErr_Occurred()) SWIG_fail;
51242 }
51243 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51251 PyObject *resultobj = 0;
51252 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51253 wxGridBagSizer *result = 0 ;
51254 void *argp1 = 0 ;
51255 int res1 = 0 ;
51256 PyObject *swig_obj[1] ;
51257
51258 if (!args) SWIG_fail;
51259 swig_obj[0] = args;
51260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51261 if (!SWIG_IsOK(res1)) {
51262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51263 }
51264 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51265 {
51266 PyThreadState* __tstate = wxPyBeginAllowThreads();
51267 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51268 wxPyEndAllowThreads(__tstate);
51269 if (PyErr_Occurred()) SWIG_fail;
51270 }
51271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51272 return resultobj;
51273 fail:
51274 return NULL;
51275 }
51276
51277
51278 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51279 PyObject *resultobj = 0;
51280 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51281 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51282 void *argp1 = 0 ;
51283 int res1 = 0 ;
51284 void *argp2 = 0 ;
51285 int res2 = 0 ;
51286 PyObject * obj0 = 0 ;
51287 PyObject * obj1 = 0 ;
51288 char * kwnames[] = {
51289 (char *) "self",(char *) "sizer", NULL
51290 };
51291
51292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51294 if (!SWIG_IsOK(res1)) {
51295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51296 }
51297 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51299 if (!SWIG_IsOK(res2)) {
51300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51301 }
51302 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51303 {
51304 PyThreadState* __tstate = wxPyBeginAllowThreads();
51305 (arg1)->SetGBSizer(arg2);
51306 wxPyEndAllowThreads(__tstate);
51307 if (PyErr_Occurred()) SWIG_fail;
51308 }
51309 resultobj = SWIG_Py_Void();
51310 return resultobj;
51311 fail:
51312 return NULL;
51313 }
51314
51315
51316 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51317 PyObject *obj;
51318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51319 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51320 return SWIG_Py_Void();
51321 }
51322
51323 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51324 return SWIG_Python_InitShadowInstance(args);
51325 }
51326
51327 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51328 PyObject *resultobj = 0;
51329 int arg1 = (int) 0 ;
51330 int arg2 = (int) 0 ;
51331 wxGridBagSizer *result = 0 ;
51332 int val1 ;
51333 int ecode1 = 0 ;
51334 int val2 ;
51335 int ecode2 = 0 ;
51336 PyObject * obj0 = 0 ;
51337 PyObject * obj1 = 0 ;
51338 char * kwnames[] = {
51339 (char *) "vgap",(char *) "hgap", NULL
51340 };
51341
51342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51343 if (obj0) {
51344 ecode1 = SWIG_AsVal_int(obj0, &val1);
51345 if (!SWIG_IsOK(ecode1)) {
51346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51347 }
51348 arg1 = static_cast< int >(val1);
51349 }
51350 if (obj1) {
51351 ecode2 = SWIG_AsVal_int(obj1, &val2);
51352 if (!SWIG_IsOK(ecode2)) {
51353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51354 }
51355 arg2 = static_cast< int >(val2);
51356 }
51357 {
51358 PyThreadState* __tstate = wxPyBeginAllowThreads();
51359 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51360 wxPyEndAllowThreads(__tstate);
51361 if (PyErr_Occurred()) SWIG_fail;
51362 }
51363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51364 return resultobj;
51365 fail:
51366 return NULL;
51367 }
51368
51369
51370 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51371 PyObject *resultobj = 0;
51372 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51373 PyObject *arg2 = (PyObject *) 0 ;
51374 wxGBPosition *arg3 = 0 ;
51375 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51376 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51377 int arg5 = (int) 0 ;
51378 int arg6 = (int) 0 ;
51379 PyObject *arg7 = (PyObject *) NULL ;
51380 wxGBSizerItem *result = 0 ;
51381 void *argp1 = 0 ;
51382 int res1 = 0 ;
51383 wxGBPosition temp3 ;
51384 wxGBSpan temp4 ;
51385 int val5 ;
51386 int ecode5 = 0 ;
51387 int val6 ;
51388 int ecode6 = 0 ;
51389 PyObject * obj0 = 0 ;
51390 PyObject * obj1 = 0 ;
51391 PyObject * obj2 = 0 ;
51392 PyObject * obj3 = 0 ;
51393 PyObject * obj4 = 0 ;
51394 PyObject * obj5 = 0 ;
51395 PyObject * obj6 = 0 ;
51396 char * kwnames[] = {
51397 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51398 };
51399
51400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51402 if (!SWIG_IsOK(res1)) {
51403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51404 }
51405 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51406 arg2 = obj1;
51407 {
51408 arg3 = &temp3;
51409 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51410 }
51411 if (obj3) {
51412 {
51413 arg4 = &temp4;
51414 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51415 }
51416 }
51417 if (obj4) {
51418 ecode5 = SWIG_AsVal_int(obj4, &val5);
51419 if (!SWIG_IsOK(ecode5)) {
51420 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51421 }
51422 arg5 = static_cast< int >(val5);
51423 }
51424 if (obj5) {
51425 ecode6 = SWIG_AsVal_int(obj5, &val6);
51426 if (!SWIG_IsOK(ecode6)) {
51427 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51428 }
51429 arg6 = static_cast< int >(val6);
51430 }
51431 if (obj6) {
51432 arg7 = obj6;
51433 }
51434 {
51435 PyThreadState* __tstate = wxPyBeginAllowThreads();
51436 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51437 wxPyEndAllowThreads(__tstate);
51438 if (PyErr_Occurred()) SWIG_fail;
51439 }
51440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51441 return resultobj;
51442 fail:
51443 return NULL;
51444 }
51445
51446
51447 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51448 PyObject *resultobj = 0;
51449 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51450 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51451 wxGBSizerItem *result = 0 ;
51452 void *argp1 = 0 ;
51453 int res1 = 0 ;
51454 int res2 = 0 ;
51455 PyObject * obj0 = 0 ;
51456 PyObject * obj1 = 0 ;
51457 char * kwnames[] = {
51458 (char *) "self",(char *) "item", NULL
51459 };
51460
51461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51463 if (!SWIG_IsOK(res1)) {
51464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51465 }
51466 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51467 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51468 if (!SWIG_IsOK(res2)) {
51469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51470 }
51471 {
51472 PyThreadState* __tstate = wxPyBeginAllowThreads();
51473 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51474 wxPyEndAllowThreads(__tstate);
51475 if (PyErr_Occurred()) SWIG_fail;
51476 }
51477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51478 return resultobj;
51479 fail:
51480 return NULL;
51481 }
51482
51483
51484 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51485 PyObject *resultobj = 0;
51486 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51487 int arg2 ;
51488 int arg3 ;
51489 wxSize result;
51490 void *argp1 = 0 ;
51491 int res1 = 0 ;
51492 int val2 ;
51493 int ecode2 = 0 ;
51494 int val3 ;
51495 int ecode3 = 0 ;
51496 PyObject * obj0 = 0 ;
51497 PyObject * obj1 = 0 ;
51498 PyObject * obj2 = 0 ;
51499 char * kwnames[] = {
51500 (char *) "self",(char *) "row",(char *) "col", NULL
51501 };
51502
51503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51505 if (!SWIG_IsOK(res1)) {
51506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51507 }
51508 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51509 ecode2 = SWIG_AsVal_int(obj1, &val2);
51510 if (!SWIG_IsOK(ecode2)) {
51511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51512 }
51513 arg2 = static_cast< int >(val2);
51514 ecode3 = SWIG_AsVal_int(obj2, &val3);
51515 if (!SWIG_IsOK(ecode3)) {
51516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51517 }
51518 arg3 = static_cast< int >(val3);
51519 {
51520 PyThreadState* __tstate = wxPyBeginAllowThreads();
51521 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51522 wxPyEndAllowThreads(__tstate);
51523 if (PyErr_Occurred()) SWIG_fail;
51524 }
51525 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51526 return resultobj;
51527 fail:
51528 return NULL;
51529 }
51530
51531
51532 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51533 PyObject *resultobj = 0;
51534 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51535 wxSize result;
51536 void *argp1 = 0 ;
51537 int res1 = 0 ;
51538 PyObject *swig_obj[1] ;
51539
51540 if (!args) SWIG_fail;
51541 swig_obj[0] = args;
51542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51543 if (!SWIG_IsOK(res1)) {
51544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51545 }
51546 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51547 {
51548 PyThreadState* __tstate = wxPyBeginAllowThreads();
51549 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51550 wxPyEndAllowThreads(__tstate);
51551 if (PyErr_Occurred()) SWIG_fail;
51552 }
51553 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51554 return resultobj;
51555 fail:
51556 return NULL;
51557 }
51558
51559
51560 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51561 PyObject *resultobj = 0;
51562 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51563 wxSize *arg2 = 0 ;
51564 void *argp1 = 0 ;
51565 int res1 = 0 ;
51566 wxSize temp2 ;
51567 PyObject * obj0 = 0 ;
51568 PyObject * obj1 = 0 ;
51569 char * kwnames[] = {
51570 (char *) "self",(char *) "sz", NULL
51571 };
51572
51573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51575 if (!SWIG_IsOK(res1)) {
51576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51577 }
51578 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51579 {
51580 arg2 = &temp2;
51581 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51582 }
51583 {
51584 PyThreadState* __tstate = wxPyBeginAllowThreads();
51585 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51586 wxPyEndAllowThreads(__tstate);
51587 if (PyErr_Occurred()) SWIG_fail;
51588 }
51589 resultobj = SWIG_Py_Void();
51590 return resultobj;
51591 fail:
51592 return NULL;
51593 }
51594
51595
51596 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51597 PyObject *resultobj = 0;
51598 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51599 wxWindow *arg2 = (wxWindow *) 0 ;
51600 wxGBPosition result;
51601 void *argp1 = 0 ;
51602 int res1 = 0 ;
51603 void *argp2 = 0 ;
51604 int res2 = 0 ;
51605
51606 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51608 if (!SWIG_IsOK(res1)) {
51609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51610 }
51611 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51612 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51613 if (!SWIG_IsOK(res2)) {
51614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51615 }
51616 arg2 = reinterpret_cast< wxWindow * >(argp2);
51617 {
51618 PyThreadState* __tstate = wxPyBeginAllowThreads();
51619 result = (arg1)->GetItemPosition(arg2);
51620 wxPyEndAllowThreads(__tstate);
51621 if (PyErr_Occurred()) SWIG_fail;
51622 }
51623 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51624 return resultobj;
51625 fail:
51626 return NULL;
51627 }
51628
51629
51630 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51631 PyObject *resultobj = 0;
51632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51633 wxSizer *arg2 = (wxSizer *) 0 ;
51634 wxGBPosition result;
51635 void *argp1 = 0 ;
51636 int res1 = 0 ;
51637 void *argp2 = 0 ;
51638 int res2 = 0 ;
51639
51640 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51642 if (!SWIG_IsOK(res1)) {
51643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51644 }
51645 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51646 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51647 if (!SWIG_IsOK(res2)) {
51648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51649 }
51650 arg2 = reinterpret_cast< wxSizer * >(argp2);
51651 {
51652 PyThreadState* __tstate = wxPyBeginAllowThreads();
51653 result = (arg1)->GetItemPosition(arg2);
51654 wxPyEndAllowThreads(__tstate);
51655 if (PyErr_Occurred()) SWIG_fail;
51656 }
51657 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51658 return resultobj;
51659 fail:
51660 return NULL;
51661 }
51662
51663
51664 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51665 PyObject *resultobj = 0;
51666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51667 size_t arg2 ;
51668 wxGBPosition result;
51669 void *argp1 = 0 ;
51670 int res1 = 0 ;
51671 size_t val2 ;
51672 int ecode2 = 0 ;
51673
51674 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51676 if (!SWIG_IsOK(res1)) {
51677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51678 }
51679 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51680 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51681 if (!SWIG_IsOK(ecode2)) {
51682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51683 }
51684 arg2 = static_cast< size_t >(val2);
51685 {
51686 PyThreadState* __tstate = wxPyBeginAllowThreads();
51687 result = (arg1)->GetItemPosition(arg2);
51688 wxPyEndAllowThreads(__tstate);
51689 if (PyErr_Occurred()) SWIG_fail;
51690 }
51691 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51692 return resultobj;
51693 fail:
51694 return NULL;
51695 }
51696
51697
51698 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51699 int argc;
51700 PyObject *argv[3];
51701
51702 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51703 --argc;
51704 if (argc == 2) {
51705 int _v = 0;
51706 {
51707 void *vptr = 0;
51708 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51709 _v = SWIG_CheckState(res);
51710 }
51711 if (!_v) goto check_1;
51712 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51713 }
51714 check_1:
51715
51716 if (argc == 2) {
51717 int _v = 0;
51718 {
51719 void *vptr = 0;
51720 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51721 _v = SWIG_CheckState(res);
51722 }
51723 if (!_v) goto check_2;
51724 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51725 }
51726 check_2:
51727
51728 if (argc == 2) {
51729 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51730 }
51731
51732 fail:
51733 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51734 return NULL;
51735 }
51736
51737
51738 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51739 PyObject *resultobj = 0;
51740 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51741 wxWindow *arg2 = (wxWindow *) 0 ;
51742 wxGBPosition *arg3 = 0 ;
51743 bool result;
51744 void *argp1 = 0 ;
51745 int res1 = 0 ;
51746 void *argp2 = 0 ;
51747 int res2 = 0 ;
51748 wxGBPosition temp3 ;
51749
51750 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51752 if (!SWIG_IsOK(res1)) {
51753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51754 }
51755 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51756 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51757 if (!SWIG_IsOK(res2)) {
51758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51759 }
51760 arg2 = reinterpret_cast< wxWindow * >(argp2);
51761 {
51762 arg3 = &temp3;
51763 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51764 }
51765 {
51766 PyThreadState* __tstate = wxPyBeginAllowThreads();
51767 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51768 wxPyEndAllowThreads(__tstate);
51769 if (PyErr_Occurred()) SWIG_fail;
51770 }
51771 {
51772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51773 }
51774 return resultobj;
51775 fail:
51776 return NULL;
51777 }
51778
51779
51780 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51781 PyObject *resultobj = 0;
51782 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51783 wxSizer *arg2 = (wxSizer *) 0 ;
51784 wxGBPosition *arg3 = 0 ;
51785 bool result;
51786 void *argp1 = 0 ;
51787 int res1 = 0 ;
51788 void *argp2 = 0 ;
51789 int res2 = 0 ;
51790 wxGBPosition temp3 ;
51791
51792 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51794 if (!SWIG_IsOK(res1)) {
51795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51796 }
51797 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51798 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51799 if (!SWIG_IsOK(res2)) {
51800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51801 }
51802 arg2 = reinterpret_cast< wxSizer * >(argp2);
51803 {
51804 arg3 = &temp3;
51805 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51806 }
51807 {
51808 PyThreadState* __tstate = wxPyBeginAllowThreads();
51809 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51810 wxPyEndAllowThreads(__tstate);
51811 if (PyErr_Occurred()) SWIG_fail;
51812 }
51813 {
51814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51815 }
51816 return resultobj;
51817 fail:
51818 return NULL;
51819 }
51820
51821
51822 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51823 PyObject *resultobj = 0;
51824 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51825 size_t arg2 ;
51826 wxGBPosition *arg3 = 0 ;
51827 bool result;
51828 void *argp1 = 0 ;
51829 int res1 = 0 ;
51830 size_t val2 ;
51831 int ecode2 = 0 ;
51832 wxGBPosition temp3 ;
51833
51834 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51836 if (!SWIG_IsOK(res1)) {
51837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51838 }
51839 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51840 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51841 if (!SWIG_IsOK(ecode2)) {
51842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51843 }
51844 arg2 = static_cast< size_t >(val2);
51845 {
51846 arg3 = &temp3;
51847 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51848 }
51849 {
51850 PyThreadState* __tstate = wxPyBeginAllowThreads();
51851 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51852 wxPyEndAllowThreads(__tstate);
51853 if (PyErr_Occurred()) SWIG_fail;
51854 }
51855 {
51856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51857 }
51858 return resultobj;
51859 fail:
51860 return NULL;
51861 }
51862
51863
51864 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51865 int argc;
51866 PyObject *argv[4];
51867
51868 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51869 --argc;
51870 if (argc == 3) {
51871 int _v = 0;
51872 {
51873 void *vptr = 0;
51874 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51875 _v = SWIG_CheckState(res);
51876 }
51877 if (!_v) goto check_1;
51878 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51879 }
51880 check_1:
51881
51882 if (argc == 3) {
51883 int _v = 0;
51884 {
51885 void *vptr = 0;
51886 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51887 _v = SWIG_CheckState(res);
51888 }
51889 if (!_v) goto check_2;
51890 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51891 }
51892 check_2:
51893
51894 if (argc == 3) {
51895 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51896 }
51897
51898 fail:
51899 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51900 return NULL;
51901 }
51902
51903
51904 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51905 PyObject *resultobj = 0;
51906 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51907 wxWindow *arg2 = (wxWindow *) 0 ;
51908 wxGBSpan result;
51909 void *argp1 = 0 ;
51910 int res1 = 0 ;
51911 void *argp2 = 0 ;
51912 int res2 = 0 ;
51913
51914 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51916 if (!SWIG_IsOK(res1)) {
51917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51918 }
51919 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51920 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51921 if (!SWIG_IsOK(res2)) {
51922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51923 }
51924 arg2 = reinterpret_cast< wxWindow * >(argp2);
51925 {
51926 PyThreadState* __tstate = wxPyBeginAllowThreads();
51927 result = (arg1)->GetItemSpan(arg2);
51928 wxPyEndAllowThreads(__tstate);
51929 if (PyErr_Occurred()) SWIG_fail;
51930 }
51931 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51932 return resultobj;
51933 fail:
51934 return NULL;
51935 }
51936
51937
51938 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51939 PyObject *resultobj = 0;
51940 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51941 wxSizer *arg2 = (wxSizer *) 0 ;
51942 wxGBSpan result;
51943 void *argp1 = 0 ;
51944 int res1 = 0 ;
51945 void *argp2 = 0 ;
51946 int res2 = 0 ;
51947
51948 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51950 if (!SWIG_IsOK(res1)) {
51951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51952 }
51953 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51954 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51955 if (!SWIG_IsOK(res2)) {
51956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51957 }
51958 arg2 = reinterpret_cast< wxSizer * >(argp2);
51959 {
51960 PyThreadState* __tstate = wxPyBeginAllowThreads();
51961 result = (arg1)->GetItemSpan(arg2);
51962 wxPyEndAllowThreads(__tstate);
51963 if (PyErr_Occurred()) SWIG_fail;
51964 }
51965 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51966 return resultobj;
51967 fail:
51968 return NULL;
51969 }
51970
51971
51972 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51973 PyObject *resultobj = 0;
51974 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51975 size_t arg2 ;
51976 wxGBSpan result;
51977 void *argp1 = 0 ;
51978 int res1 = 0 ;
51979 size_t val2 ;
51980 int ecode2 = 0 ;
51981
51982 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51984 if (!SWIG_IsOK(res1)) {
51985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51986 }
51987 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51988 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51989 if (!SWIG_IsOK(ecode2)) {
51990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51991 }
51992 arg2 = static_cast< size_t >(val2);
51993 {
51994 PyThreadState* __tstate = wxPyBeginAllowThreads();
51995 result = (arg1)->GetItemSpan(arg2);
51996 wxPyEndAllowThreads(__tstate);
51997 if (PyErr_Occurred()) SWIG_fail;
51998 }
51999 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52000 return resultobj;
52001 fail:
52002 return NULL;
52003 }
52004
52005
52006 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52007 int argc;
52008 PyObject *argv[3];
52009
52010 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52011 --argc;
52012 if (argc == 2) {
52013 int _v = 0;
52014 {
52015 void *vptr = 0;
52016 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52017 _v = SWIG_CheckState(res);
52018 }
52019 if (!_v) goto check_1;
52020 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52021 }
52022 check_1:
52023
52024 if (argc == 2) {
52025 int _v = 0;
52026 {
52027 void *vptr = 0;
52028 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52029 _v = SWIG_CheckState(res);
52030 }
52031 if (!_v) goto check_2;
52032 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52033 }
52034 check_2:
52035
52036 if (argc == 2) {
52037 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52038 }
52039
52040 fail:
52041 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52042 return NULL;
52043 }
52044
52045
52046 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52047 PyObject *resultobj = 0;
52048 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52049 wxWindow *arg2 = (wxWindow *) 0 ;
52050 wxGBSpan *arg3 = 0 ;
52051 bool result;
52052 void *argp1 = 0 ;
52053 int res1 = 0 ;
52054 void *argp2 = 0 ;
52055 int res2 = 0 ;
52056 wxGBSpan temp3 ;
52057
52058 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52060 if (!SWIG_IsOK(res1)) {
52061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52062 }
52063 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52064 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52065 if (!SWIG_IsOK(res2)) {
52066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52067 }
52068 arg2 = reinterpret_cast< wxWindow * >(argp2);
52069 {
52070 arg3 = &temp3;
52071 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52072 }
52073 {
52074 PyThreadState* __tstate = wxPyBeginAllowThreads();
52075 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52076 wxPyEndAllowThreads(__tstate);
52077 if (PyErr_Occurred()) SWIG_fail;
52078 }
52079 {
52080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52081 }
52082 return resultobj;
52083 fail:
52084 return NULL;
52085 }
52086
52087
52088 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52089 PyObject *resultobj = 0;
52090 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52091 wxSizer *arg2 = (wxSizer *) 0 ;
52092 wxGBSpan *arg3 = 0 ;
52093 bool result;
52094 void *argp1 = 0 ;
52095 int res1 = 0 ;
52096 void *argp2 = 0 ;
52097 int res2 = 0 ;
52098 wxGBSpan temp3 ;
52099
52100 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52102 if (!SWIG_IsOK(res1)) {
52103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52104 }
52105 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52106 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52107 if (!SWIG_IsOK(res2)) {
52108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52109 }
52110 arg2 = reinterpret_cast< wxSizer * >(argp2);
52111 {
52112 arg3 = &temp3;
52113 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52114 }
52115 {
52116 PyThreadState* __tstate = wxPyBeginAllowThreads();
52117 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52118 wxPyEndAllowThreads(__tstate);
52119 if (PyErr_Occurred()) SWIG_fail;
52120 }
52121 {
52122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52123 }
52124 return resultobj;
52125 fail:
52126 return NULL;
52127 }
52128
52129
52130 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52131 PyObject *resultobj = 0;
52132 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52133 size_t arg2 ;
52134 wxGBSpan *arg3 = 0 ;
52135 bool result;
52136 void *argp1 = 0 ;
52137 int res1 = 0 ;
52138 size_t val2 ;
52139 int ecode2 = 0 ;
52140 wxGBSpan temp3 ;
52141
52142 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52144 if (!SWIG_IsOK(res1)) {
52145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52146 }
52147 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52148 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52149 if (!SWIG_IsOK(ecode2)) {
52150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52151 }
52152 arg2 = static_cast< size_t >(val2);
52153 {
52154 arg3 = &temp3;
52155 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52156 }
52157 {
52158 PyThreadState* __tstate = wxPyBeginAllowThreads();
52159 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52160 wxPyEndAllowThreads(__tstate);
52161 if (PyErr_Occurred()) SWIG_fail;
52162 }
52163 {
52164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52165 }
52166 return resultobj;
52167 fail:
52168 return NULL;
52169 }
52170
52171
52172 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52173 int argc;
52174 PyObject *argv[4];
52175
52176 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52177 --argc;
52178 if (argc == 3) {
52179 int _v = 0;
52180 {
52181 void *vptr = 0;
52182 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52183 _v = SWIG_CheckState(res);
52184 }
52185 if (!_v) goto check_1;
52186 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52187 }
52188 check_1:
52189
52190 if (argc == 3) {
52191 int _v = 0;
52192 {
52193 void *vptr = 0;
52194 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52195 _v = SWIG_CheckState(res);
52196 }
52197 if (!_v) goto check_2;
52198 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52199 }
52200 check_2:
52201
52202 if (argc == 3) {
52203 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52204 }
52205
52206 fail:
52207 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52208 return NULL;
52209 }
52210
52211
52212 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52213 PyObject *resultobj = 0;
52214 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52215 wxWindow *arg2 = (wxWindow *) 0 ;
52216 wxGBSizerItem *result = 0 ;
52217 void *argp1 = 0 ;
52218 int res1 = 0 ;
52219 void *argp2 = 0 ;
52220 int res2 = 0 ;
52221
52222 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52224 if (!SWIG_IsOK(res1)) {
52225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52226 }
52227 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52228 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52229 if (!SWIG_IsOK(res2)) {
52230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52231 }
52232 arg2 = reinterpret_cast< wxWindow * >(argp2);
52233 {
52234 PyThreadState* __tstate = wxPyBeginAllowThreads();
52235 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52236 wxPyEndAllowThreads(__tstate);
52237 if (PyErr_Occurred()) SWIG_fail;
52238 }
52239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52240 return resultobj;
52241 fail:
52242 return NULL;
52243 }
52244
52245
52246 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52247 PyObject *resultobj = 0;
52248 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52249 wxSizer *arg2 = (wxSizer *) 0 ;
52250 wxGBSizerItem *result = 0 ;
52251 void *argp1 = 0 ;
52252 int res1 = 0 ;
52253 void *argp2 = 0 ;
52254 int res2 = 0 ;
52255
52256 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52258 if (!SWIG_IsOK(res1)) {
52259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52260 }
52261 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52262 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52263 if (!SWIG_IsOK(res2)) {
52264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52265 }
52266 arg2 = reinterpret_cast< wxSizer * >(argp2);
52267 {
52268 PyThreadState* __tstate = wxPyBeginAllowThreads();
52269 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52270 wxPyEndAllowThreads(__tstate);
52271 if (PyErr_Occurred()) SWIG_fail;
52272 }
52273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52274 return resultobj;
52275 fail:
52276 return NULL;
52277 }
52278
52279
52280 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52281 int argc;
52282 PyObject *argv[3];
52283
52284 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52285 --argc;
52286 if (argc == 2) {
52287 int _v = 0;
52288 {
52289 void *vptr = 0;
52290 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52291 _v = SWIG_CheckState(res);
52292 }
52293 if (!_v) goto check_1;
52294 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52295 }
52296 check_1:
52297
52298 if (argc == 2) {
52299 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52300 }
52301
52302 fail:
52303 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52304 return NULL;
52305 }
52306
52307
52308 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52309 PyObject *resultobj = 0;
52310 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52311 wxGBPosition *arg2 = 0 ;
52312 wxGBSizerItem *result = 0 ;
52313 void *argp1 = 0 ;
52314 int res1 = 0 ;
52315 wxGBPosition temp2 ;
52316 PyObject * obj0 = 0 ;
52317 PyObject * obj1 = 0 ;
52318 char * kwnames[] = {
52319 (char *) "self",(char *) "pos", NULL
52320 };
52321
52322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52324 if (!SWIG_IsOK(res1)) {
52325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52326 }
52327 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52328 {
52329 arg2 = &temp2;
52330 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52331 }
52332 {
52333 PyThreadState* __tstate = wxPyBeginAllowThreads();
52334 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52335 wxPyEndAllowThreads(__tstate);
52336 if (PyErr_Occurred()) SWIG_fail;
52337 }
52338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52339 return resultobj;
52340 fail:
52341 return NULL;
52342 }
52343
52344
52345 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52346 PyObject *resultobj = 0;
52347 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52348 wxPoint *arg2 = 0 ;
52349 wxGBSizerItem *result = 0 ;
52350 void *argp1 = 0 ;
52351 int res1 = 0 ;
52352 wxPoint temp2 ;
52353 PyObject * obj0 = 0 ;
52354 PyObject * obj1 = 0 ;
52355 char * kwnames[] = {
52356 (char *) "self",(char *) "pt", NULL
52357 };
52358
52359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52361 if (!SWIG_IsOK(res1)) {
52362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52363 }
52364 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52365 {
52366 arg2 = &temp2;
52367 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52368 }
52369 {
52370 PyThreadState* __tstate = wxPyBeginAllowThreads();
52371 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52372 wxPyEndAllowThreads(__tstate);
52373 if (PyErr_Occurred()) SWIG_fail;
52374 }
52375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52376 return resultobj;
52377 fail:
52378 return NULL;
52379 }
52380
52381
52382 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52383 PyObject *resultobj = 0;
52384 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52385 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52386 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52387 bool result;
52388 void *argp1 = 0 ;
52389 int res1 = 0 ;
52390 void *argp2 = 0 ;
52391 int res2 = 0 ;
52392 void *argp3 = 0 ;
52393 int res3 = 0 ;
52394 PyObject * obj0 = 0 ;
52395 PyObject * obj1 = 0 ;
52396 PyObject * obj2 = 0 ;
52397 char * kwnames[] = {
52398 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52399 };
52400
52401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52403 if (!SWIG_IsOK(res1)) {
52404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52405 }
52406 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52407 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52408 if (!SWIG_IsOK(res2)) {
52409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52410 }
52411 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52412 if (obj2) {
52413 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52414 if (!SWIG_IsOK(res3)) {
52415 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52416 }
52417 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52418 }
52419 {
52420 PyThreadState* __tstate = wxPyBeginAllowThreads();
52421 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52422 wxPyEndAllowThreads(__tstate);
52423 if (PyErr_Occurred()) SWIG_fail;
52424 }
52425 {
52426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52427 }
52428 return resultobj;
52429 fail:
52430 return NULL;
52431 }
52432
52433
52434 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52435 PyObject *resultobj = 0;
52436 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52437 wxGBPosition *arg2 = 0 ;
52438 wxGBSpan *arg3 = 0 ;
52439 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52440 bool result;
52441 void *argp1 = 0 ;
52442 int res1 = 0 ;
52443 wxGBPosition temp2 ;
52444 wxGBSpan temp3 ;
52445 void *argp4 = 0 ;
52446 int res4 = 0 ;
52447 PyObject * obj0 = 0 ;
52448 PyObject * obj1 = 0 ;
52449 PyObject * obj2 = 0 ;
52450 PyObject * obj3 = 0 ;
52451 char * kwnames[] = {
52452 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52453 };
52454
52455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52457 if (!SWIG_IsOK(res1)) {
52458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52459 }
52460 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52461 {
52462 arg2 = &temp2;
52463 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52464 }
52465 {
52466 arg3 = &temp3;
52467 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52468 }
52469 if (obj3) {
52470 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52471 if (!SWIG_IsOK(res4)) {
52472 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52473 }
52474 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52475 }
52476 {
52477 PyThreadState* __tstate = wxPyBeginAllowThreads();
52478 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52479 wxPyEndAllowThreads(__tstate);
52480 if (PyErr_Occurred()) SWIG_fail;
52481 }
52482 {
52483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52484 }
52485 return resultobj;
52486 fail:
52487 return NULL;
52488 }
52489
52490
52491 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52492 PyObject *obj;
52493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52494 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52495 return SWIG_Py_Void();
52496 }
52497
52498 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52499 return SWIG_Python_InitShadowInstance(args);
52500 }
52501
52502 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52503 PyObject *resultobj = 0;
52504 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52505 wxRelationship arg2 ;
52506 wxWindow *arg3 = (wxWindow *) 0 ;
52507 wxEdge arg4 ;
52508 int arg5 = (int) 0 ;
52509 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52510 void *argp1 = 0 ;
52511 int res1 = 0 ;
52512 int val2 ;
52513 int ecode2 = 0 ;
52514 void *argp3 = 0 ;
52515 int res3 = 0 ;
52516 int val4 ;
52517 int ecode4 = 0 ;
52518 int val5 ;
52519 int ecode5 = 0 ;
52520 int val6 ;
52521 int ecode6 = 0 ;
52522 PyObject * obj0 = 0 ;
52523 PyObject * obj1 = 0 ;
52524 PyObject * obj2 = 0 ;
52525 PyObject * obj3 = 0 ;
52526 PyObject * obj4 = 0 ;
52527 PyObject * obj5 = 0 ;
52528 char * kwnames[] = {
52529 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52530 };
52531
52532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52534 if (!SWIG_IsOK(res1)) {
52535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52536 }
52537 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52538 ecode2 = SWIG_AsVal_int(obj1, &val2);
52539 if (!SWIG_IsOK(ecode2)) {
52540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52541 }
52542 arg2 = static_cast< wxRelationship >(val2);
52543 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52544 if (!SWIG_IsOK(res3)) {
52545 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52546 }
52547 arg3 = reinterpret_cast< wxWindow * >(argp3);
52548 ecode4 = SWIG_AsVal_int(obj3, &val4);
52549 if (!SWIG_IsOK(ecode4)) {
52550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52551 }
52552 arg4 = static_cast< wxEdge >(val4);
52553 if (obj4) {
52554 ecode5 = SWIG_AsVal_int(obj4, &val5);
52555 if (!SWIG_IsOK(ecode5)) {
52556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52557 }
52558 arg5 = static_cast< int >(val5);
52559 }
52560 if (obj5) {
52561 ecode6 = SWIG_AsVal_int(obj5, &val6);
52562 if (!SWIG_IsOK(ecode6)) {
52563 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52564 }
52565 arg6 = static_cast< int >(val6);
52566 }
52567 {
52568 PyThreadState* __tstate = wxPyBeginAllowThreads();
52569 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52570 wxPyEndAllowThreads(__tstate);
52571 if (PyErr_Occurred()) SWIG_fail;
52572 }
52573 resultobj = SWIG_Py_Void();
52574 return resultobj;
52575 fail:
52576 return NULL;
52577 }
52578
52579
52580 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52581 PyObject *resultobj = 0;
52582 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52583 wxWindow *arg2 = (wxWindow *) 0 ;
52584 int arg3 = (int) 0 ;
52585 void *argp1 = 0 ;
52586 int res1 = 0 ;
52587 void *argp2 = 0 ;
52588 int res2 = 0 ;
52589 int val3 ;
52590 int ecode3 = 0 ;
52591 PyObject * obj0 = 0 ;
52592 PyObject * obj1 = 0 ;
52593 PyObject * obj2 = 0 ;
52594 char * kwnames[] = {
52595 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52596 };
52597
52598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52600 if (!SWIG_IsOK(res1)) {
52601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52602 }
52603 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52604 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52605 if (!SWIG_IsOK(res2)) {
52606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52607 }
52608 arg2 = reinterpret_cast< wxWindow * >(argp2);
52609 if (obj2) {
52610 ecode3 = SWIG_AsVal_int(obj2, &val3);
52611 if (!SWIG_IsOK(ecode3)) {
52612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52613 }
52614 arg3 = static_cast< int >(val3);
52615 }
52616 {
52617 PyThreadState* __tstate = wxPyBeginAllowThreads();
52618 (arg1)->LeftOf(arg2,arg3);
52619 wxPyEndAllowThreads(__tstate);
52620 if (PyErr_Occurred()) SWIG_fail;
52621 }
52622 resultobj = SWIG_Py_Void();
52623 return resultobj;
52624 fail:
52625 return NULL;
52626 }
52627
52628
52629 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52630 PyObject *resultobj = 0;
52631 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52632 wxWindow *arg2 = (wxWindow *) 0 ;
52633 int arg3 = (int) 0 ;
52634 void *argp1 = 0 ;
52635 int res1 = 0 ;
52636 void *argp2 = 0 ;
52637 int res2 = 0 ;
52638 int val3 ;
52639 int ecode3 = 0 ;
52640 PyObject * obj0 = 0 ;
52641 PyObject * obj1 = 0 ;
52642 PyObject * obj2 = 0 ;
52643 char * kwnames[] = {
52644 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52645 };
52646
52647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52649 if (!SWIG_IsOK(res1)) {
52650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52651 }
52652 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52654 if (!SWIG_IsOK(res2)) {
52655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52656 }
52657 arg2 = reinterpret_cast< wxWindow * >(argp2);
52658 if (obj2) {
52659 ecode3 = SWIG_AsVal_int(obj2, &val3);
52660 if (!SWIG_IsOK(ecode3)) {
52661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52662 }
52663 arg3 = static_cast< int >(val3);
52664 }
52665 {
52666 PyThreadState* __tstate = wxPyBeginAllowThreads();
52667 (arg1)->RightOf(arg2,arg3);
52668 wxPyEndAllowThreads(__tstate);
52669 if (PyErr_Occurred()) SWIG_fail;
52670 }
52671 resultobj = SWIG_Py_Void();
52672 return resultobj;
52673 fail:
52674 return NULL;
52675 }
52676
52677
52678 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52679 PyObject *resultobj = 0;
52680 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52681 wxWindow *arg2 = (wxWindow *) 0 ;
52682 int arg3 = (int) 0 ;
52683 void *argp1 = 0 ;
52684 int res1 = 0 ;
52685 void *argp2 = 0 ;
52686 int res2 = 0 ;
52687 int val3 ;
52688 int ecode3 = 0 ;
52689 PyObject * obj0 = 0 ;
52690 PyObject * obj1 = 0 ;
52691 PyObject * obj2 = 0 ;
52692 char * kwnames[] = {
52693 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52694 };
52695
52696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52698 if (!SWIG_IsOK(res1)) {
52699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52700 }
52701 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52703 if (!SWIG_IsOK(res2)) {
52704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52705 }
52706 arg2 = reinterpret_cast< wxWindow * >(argp2);
52707 if (obj2) {
52708 ecode3 = SWIG_AsVal_int(obj2, &val3);
52709 if (!SWIG_IsOK(ecode3)) {
52710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52711 }
52712 arg3 = static_cast< int >(val3);
52713 }
52714 {
52715 PyThreadState* __tstate = wxPyBeginAllowThreads();
52716 (arg1)->Above(arg2,arg3);
52717 wxPyEndAllowThreads(__tstate);
52718 if (PyErr_Occurred()) SWIG_fail;
52719 }
52720 resultobj = SWIG_Py_Void();
52721 return resultobj;
52722 fail:
52723 return NULL;
52724 }
52725
52726
52727 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52728 PyObject *resultobj = 0;
52729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52730 wxWindow *arg2 = (wxWindow *) 0 ;
52731 int arg3 = (int) 0 ;
52732 void *argp1 = 0 ;
52733 int res1 = 0 ;
52734 void *argp2 = 0 ;
52735 int res2 = 0 ;
52736 int val3 ;
52737 int ecode3 = 0 ;
52738 PyObject * obj0 = 0 ;
52739 PyObject * obj1 = 0 ;
52740 PyObject * obj2 = 0 ;
52741 char * kwnames[] = {
52742 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52743 };
52744
52745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52747 if (!SWIG_IsOK(res1)) {
52748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52749 }
52750 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52752 if (!SWIG_IsOK(res2)) {
52753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52754 }
52755 arg2 = reinterpret_cast< wxWindow * >(argp2);
52756 if (obj2) {
52757 ecode3 = SWIG_AsVal_int(obj2, &val3);
52758 if (!SWIG_IsOK(ecode3)) {
52759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52760 }
52761 arg3 = static_cast< int >(val3);
52762 }
52763 {
52764 PyThreadState* __tstate = wxPyBeginAllowThreads();
52765 (arg1)->Below(arg2,arg3);
52766 wxPyEndAllowThreads(__tstate);
52767 if (PyErr_Occurred()) SWIG_fail;
52768 }
52769 resultobj = SWIG_Py_Void();
52770 return resultobj;
52771 fail:
52772 return NULL;
52773 }
52774
52775
52776 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52777 PyObject *resultobj = 0;
52778 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52779 wxWindow *arg2 = (wxWindow *) 0 ;
52780 wxEdge arg3 ;
52781 int arg4 = (int) 0 ;
52782 void *argp1 = 0 ;
52783 int res1 = 0 ;
52784 void *argp2 = 0 ;
52785 int res2 = 0 ;
52786 int val3 ;
52787 int ecode3 = 0 ;
52788 int val4 ;
52789 int ecode4 = 0 ;
52790 PyObject * obj0 = 0 ;
52791 PyObject * obj1 = 0 ;
52792 PyObject * obj2 = 0 ;
52793 PyObject * obj3 = 0 ;
52794 char * kwnames[] = {
52795 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52796 };
52797
52798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52800 if (!SWIG_IsOK(res1)) {
52801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52802 }
52803 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52804 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52805 if (!SWIG_IsOK(res2)) {
52806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52807 }
52808 arg2 = reinterpret_cast< wxWindow * >(argp2);
52809 ecode3 = SWIG_AsVal_int(obj2, &val3);
52810 if (!SWIG_IsOK(ecode3)) {
52811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52812 }
52813 arg3 = static_cast< wxEdge >(val3);
52814 if (obj3) {
52815 ecode4 = SWIG_AsVal_int(obj3, &val4);
52816 if (!SWIG_IsOK(ecode4)) {
52817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52818 }
52819 arg4 = static_cast< int >(val4);
52820 }
52821 {
52822 PyThreadState* __tstate = wxPyBeginAllowThreads();
52823 (arg1)->SameAs(arg2,arg3,arg4);
52824 wxPyEndAllowThreads(__tstate);
52825 if (PyErr_Occurred()) SWIG_fail;
52826 }
52827 resultobj = SWIG_Py_Void();
52828 return resultobj;
52829 fail:
52830 return NULL;
52831 }
52832
52833
52834 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52835 PyObject *resultobj = 0;
52836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52837 wxWindow *arg2 = (wxWindow *) 0 ;
52838 wxEdge arg3 ;
52839 int arg4 ;
52840 void *argp1 = 0 ;
52841 int res1 = 0 ;
52842 void *argp2 = 0 ;
52843 int res2 = 0 ;
52844 int val3 ;
52845 int ecode3 = 0 ;
52846 int val4 ;
52847 int ecode4 = 0 ;
52848 PyObject * obj0 = 0 ;
52849 PyObject * obj1 = 0 ;
52850 PyObject * obj2 = 0 ;
52851 PyObject * obj3 = 0 ;
52852 char * kwnames[] = {
52853 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52854 };
52855
52856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52858 if (!SWIG_IsOK(res1)) {
52859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52860 }
52861 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52863 if (!SWIG_IsOK(res2)) {
52864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52865 }
52866 arg2 = reinterpret_cast< wxWindow * >(argp2);
52867 ecode3 = SWIG_AsVal_int(obj2, &val3);
52868 if (!SWIG_IsOK(ecode3)) {
52869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52870 }
52871 arg3 = static_cast< wxEdge >(val3);
52872 ecode4 = SWIG_AsVal_int(obj3, &val4);
52873 if (!SWIG_IsOK(ecode4)) {
52874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52875 }
52876 arg4 = static_cast< int >(val4);
52877 {
52878 PyThreadState* __tstate = wxPyBeginAllowThreads();
52879 (arg1)->PercentOf(arg2,arg3,arg4);
52880 wxPyEndAllowThreads(__tstate);
52881 if (PyErr_Occurred()) SWIG_fail;
52882 }
52883 resultobj = SWIG_Py_Void();
52884 return resultobj;
52885 fail:
52886 return NULL;
52887 }
52888
52889
52890 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52891 PyObject *resultobj = 0;
52892 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52893 int arg2 ;
52894 void *argp1 = 0 ;
52895 int res1 = 0 ;
52896 int val2 ;
52897 int ecode2 = 0 ;
52898 PyObject * obj0 = 0 ;
52899 PyObject * obj1 = 0 ;
52900 char * kwnames[] = {
52901 (char *) "self",(char *) "val", NULL
52902 };
52903
52904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52906 if (!SWIG_IsOK(res1)) {
52907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52908 }
52909 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52910 ecode2 = SWIG_AsVal_int(obj1, &val2);
52911 if (!SWIG_IsOK(ecode2)) {
52912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52913 }
52914 arg2 = static_cast< int >(val2);
52915 {
52916 PyThreadState* __tstate = wxPyBeginAllowThreads();
52917 (arg1)->Absolute(arg2);
52918 wxPyEndAllowThreads(__tstate);
52919 if (PyErr_Occurred()) SWIG_fail;
52920 }
52921 resultobj = SWIG_Py_Void();
52922 return resultobj;
52923 fail:
52924 return NULL;
52925 }
52926
52927
52928 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52929 PyObject *resultobj = 0;
52930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52931 void *argp1 = 0 ;
52932 int res1 = 0 ;
52933 PyObject *swig_obj[1] ;
52934
52935 if (!args) SWIG_fail;
52936 swig_obj[0] = args;
52937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52938 if (!SWIG_IsOK(res1)) {
52939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52940 }
52941 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52942 {
52943 PyThreadState* __tstate = wxPyBeginAllowThreads();
52944 (arg1)->Unconstrained();
52945 wxPyEndAllowThreads(__tstate);
52946 if (PyErr_Occurred()) SWIG_fail;
52947 }
52948 resultobj = SWIG_Py_Void();
52949 return resultobj;
52950 fail:
52951 return NULL;
52952 }
52953
52954
52955 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52956 PyObject *resultobj = 0;
52957 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52958 void *argp1 = 0 ;
52959 int res1 = 0 ;
52960 PyObject *swig_obj[1] ;
52961
52962 if (!args) SWIG_fail;
52963 swig_obj[0] = args;
52964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52965 if (!SWIG_IsOK(res1)) {
52966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52967 }
52968 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52969 {
52970 PyThreadState* __tstate = wxPyBeginAllowThreads();
52971 (arg1)->AsIs();
52972 wxPyEndAllowThreads(__tstate);
52973 if (PyErr_Occurred()) SWIG_fail;
52974 }
52975 resultobj = SWIG_Py_Void();
52976 return resultobj;
52977 fail:
52978 return NULL;
52979 }
52980
52981
52982 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52983 PyObject *resultobj = 0;
52984 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52985 wxWindow *result = 0 ;
52986 void *argp1 = 0 ;
52987 int res1 = 0 ;
52988 PyObject *swig_obj[1] ;
52989
52990 if (!args) SWIG_fail;
52991 swig_obj[0] = args;
52992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52993 if (!SWIG_IsOK(res1)) {
52994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52995 }
52996 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52997 {
52998 PyThreadState* __tstate = wxPyBeginAllowThreads();
52999 result = (wxWindow *)(arg1)->GetOtherWindow();
53000 wxPyEndAllowThreads(__tstate);
53001 if (PyErr_Occurred()) SWIG_fail;
53002 }
53003 {
53004 resultobj = wxPyMake_wxObject(result, 0);
53005 }
53006 return resultobj;
53007 fail:
53008 return NULL;
53009 }
53010
53011
53012 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53013 PyObject *resultobj = 0;
53014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53015 wxEdge result;
53016 void *argp1 = 0 ;
53017 int res1 = 0 ;
53018 PyObject *swig_obj[1] ;
53019
53020 if (!args) SWIG_fail;
53021 swig_obj[0] = args;
53022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53023 if (!SWIG_IsOK(res1)) {
53024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53025 }
53026 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53027 {
53028 PyThreadState* __tstate = wxPyBeginAllowThreads();
53029 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53030 wxPyEndAllowThreads(__tstate);
53031 if (PyErr_Occurred()) SWIG_fail;
53032 }
53033 resultobj = SWIG_From_int(static_cast< int >(result));
53034 return resultobj;
53035 fail:
53036 return NULL;
53037 }
53038
53039
53040 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53041 PyObject *resultobj = 0;
53042 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53043 wxEdge arg2 ;
53044 void *argp1 = 0 ;
53045 int res1 = 0 ;
53046 int val2 ;
53047 int ecode2 = 0 ;
53048 PyObject * obj0 = 0 ;
53049 PyObject * obj1 = 0 ;
53050 char * kwnames[] = {
53051 (char *) "self",(char *) "which", NULL
53052 };
53053
53054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53056 if (!SWIG_IsOK(res1)) {
53057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53058 }
53059 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53060 ecode2 = SWIG_AsVal_int(obj1, &val2);
53061 if (!SWIG_IsOK(ecode2)) {
53062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53063 }
53064 arg2 = static_cast< wxEdge >(val2);
53065 {
53066 PyThreadState* __tstate = wxPyBeginAllowThreads();
53067 (arg1)->SetEdge(arg2);
53068 wxPyEndAllowThreads(__tstate);
53069 if (PyErr_Occurred()) SWIG_fail;
53070 }
53071 resultobj = SWIG_Py_Void();
53072 return resultobj;
53073 fail:
53074 return NULL;
53075 }
53076
53077
53078 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53079 PyObject *resultobj = 0;
53080 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53081 int arg2 ;
53082 void *argp1 = 0 ;
53083 int res1 = 0 ;
53084 int val2 ;
53085 int ecode2 = 0 ;
53086 PyObject * obj0 = 0 ;
53087 PyObject * obj1 = 0 ;
53088 char * kwnames[] = {
53089 (char *) "self",(char *) "v", NULL
53090 };
53091
53092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53094 if (!SWIG_IsOK(res1)) {
53095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53096 }
53097 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53098 ecode2 = SWIG_AsVal_int(obj1, &val2);
53099 if (!SWIG_IsOK(ecode2)) {
53100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53101 }
53102 arg2 = static_cast< int >(val2);
53103 {
53104 PyThreadState* __tstate = wxPyBeginAllowThreads();
53105 (arg1)->SetValue(arg2);
53106 wxPyEndAllowThreads(__tstate);
53107 if (PyErr_Occurred()) SWIG_fail;
53108 }
53109 resultobj = SWIG_Py_Void();
53110 return resultobj;
53111 fail:
53112 return NULL;
53113 }
53114
53115
53116 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53117 PyObject *resultobj = 0;
53118 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53119 int result;
53120 void *argp1 = 0 ;
53121 int res1 = 0 ;
53122 PyObject *swig_obj[1] ;
53123
53124 if (!args) SWIG_fail;
53125 swig_obj[0] = args;
53126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53127 if (!SWIG_IsOK(res1)) {
53128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53129 }
53130 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53131 {
53132 PyThreadState* __tstate = wxPyBeginAllowThreads();
53133 result = (int)(arg1)->GetMargin();
53134 wxPyEndAllowThreads(__tstate);
53135 if (PyErr_Occurred()) SWIG_fail;
53136 }
53137 resultobj = SWIG_From_int(static_cast< int >(result));
53138 return resultobj;
53139 fail:
53140 return NULL;
53141 }
53142
53143
53144 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53145 PyObject *resultobj = 0;
53146 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53147 int arg2 ;
53148 void *argp1 = 0 ;
53149 int res1 = 0 ;
53150 int val2 ;
53151 int ecode2 = 0 ;
53152 PyObject * obj0 = 0 ;
53153 PyObject * obj1 = 0 ;
53154 char * kwnames[] = {
53155 (char *) "self",(char *) "m", NULL
53156 };
53157
53158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53160 if (!SWIG_IsOK(res1)) {
53161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53162 }
53163 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53164 ecode2 = SWIG_AsVal_int(obj1, &val2);
53165 if (!SWIG_IsOK(ecode2)) {
53166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53167 }
53168 arg2 = static_cast< int >(val2);
53169 {
53170 PyThreadState* __tstate = wxPyBeginAllowThreads();
53171 (arg1)->SetMargin(arg2);
53172 wxPyEndAllowThreads(__tstate);
53173 if (PyErr_Occurred()) SWIG_fail;
53174 }
53175 resultobj = SWIG_Py_Void();
53176 return resultobj;
53177 fail:
53178 return NULL;
53179 }
53180
53181
53182 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53183 PyObject *resultobj = 0;
53184 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53185 int result;
53186 void *argp1 = 0 ;
53187 int res1 = 0 ;
53188 PyObject *swig_obj[1] ;
53189
53190 if (!args) SWIG_fail;
53191 swig_obj[0] = args;
53192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53193 if (!SWIG_IsOK(res1)) {
53194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53195 }
53196 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53197 {
53198 PyThreadState* __tstate = wxPyBeginAllowThreads();
53199 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53200 wxPyEndAllowThreads(__tstate);
53201 if (PyErr_Occurred()) SWIG_fail;
53202 }
53203 resultobj = SWIG_From_int(static_cast< int >(result));
53204 return resultobj;
53205 fail:
53206 return NULL;
53207 }
53208
53209
53210 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53211 PyObject *resultobj = 0;
53212 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53213 int result;
53214 void *argp1 = 0 ;
53215 int res1 = 0 ;
53216 PyObject *swig_obj[1] ;
53217
53218 if (!args) SWIG_fail;
53219 swig_obj[0] = args;
53220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53221 if (!SWIG_IsOK(res1)) {
53222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53223 }
53224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53225 {
53226 PyThreadState* __tstate = wxPyBeginAllowThreads();
53227 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53228 wxPyEndAllowThreads(__tstate);
53229 if (PyErr_Occurred()) SWIG_fail;
53230 }
53231 resultobj = SWIG_From_int(static_cast< int >(result));
53232 return resultobj;
53233 fail:
53234 return NULL;
53235 }
53236
53237
53238 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53239 PyObject *resultobj = 0;
53240 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53241 int result;
53242 void *argp1 = 0 ;
53243 int res1 = 0 ;
53244 PyObject *swig_obj[1] ;
53245
53246 if (!args) SWIG_fail;
53247 swig_obj[0] = args;
53248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53249 if (!SWIG_IsOK(res1)) {
53250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53251 }
53252 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53253 {
53254 PyThreadState* __tstate = wxPyBeginAllowThreads();
53255 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53256 wxPyEndAllowThreads(__tstate);
53257 if (PyErr_Occurred()) SWIG_fail;
53258 }
53259 resultobj = SWIG_From_int(static_cast< int >(result));
53260 return resultobj;
53261 fail:
53262 return NULL;
53263 }
53264
53265
53266 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53267 PyObject *resultobj = 0;
53268 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53269 bool result;
53270 void *argp1 = 0 ;
53271 int res1 = 0 ;
53272 PyObject *swig_obj[1] ;
53273
53274 if (!args) SWIG_fail;
53275 swig_obj[0] = args;
53276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53277 if (!SWIG_IsOK(res1)) {
53278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53279 }
53280 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53281 {
53282 PyThreadState* __tstate = wxPyBeginAllowThreads();
53283 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53284 wxPyEndAllowThreads(__tstate);
53285 if (PyErr_Occurred()) SWIG_fail;
53286 }
53287 {
53288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53289 }
53290 return resultobj;
53291 fail:
53292 return NULL;
53293 }
53294
53295
53296 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53297 PyObject *resultobj = 0;
53298 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53299 bool arg2 ;
53300 void *argp1 = 0 ;
53301 int res1 = 0 ;
53302 bool val2 ;
53303 int ecode2 = 0 ;
53304 PyObject * obj0 = 0 ;
53305 PyObject * obj1 = 0 ;
53306 char * kwnames[] = {
53307 (char *) "self",(char *) "d", NULL
53308 };
53309
53310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53312 if (!SWIG_IsOK(res1)) {
53313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53314 }
53315 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53317 if (!SWIG_IsOK(ecode2)) {
53318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53319 }
53320 arg2 = static_cast< bool >(val2);
53321 {
53322 PyThreadState* __tstate = wxPyBeginAllowThreads();
53323 (arg1)->SetDone(arg2);
53324 wxPyEndAllowThreads(__tstate);
53325 if (PyErr_Occurred()) SWIG_fail;
53326 }
53327 resultobj = SWIG_Py_Void();
53328 return resultobj;
53329 fail:
53330 return NULL;
53331 }
53332
53333
53334 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53335 PyObject *resultobj = 0;
53336 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53337 wxRelationship result;
53338 void *argp1 = 0 ;
53339 int res1 = 0 ;
53340 PyObject *swig_obj[1] ;
53341
53342 if (!args) SWIG_fail;
53343 swig_obj[0] = args;
53344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53345 if (!SWIG_IsOK(res1)) {
53346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53347 }
53348 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53349 {
53350 PyThreadState* __tstate = wxPyBeginAllowThreads();
53351 result = (wxRelationship)(arg1)->GetRelationship();
53352 wxPyEndAllowThreads(__tstate);
53353 if (PyErr_Occurred()) SWIG_fail;
53354 }
53355 resultobj = SWIG_From_int(static_cast< int >(result));
53356 return resultobj;
53357 fail:
53358 return NULL;
53359 }
53360
53361
53362 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53363 PyObject *resultobj = 0;
53364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53365 wxRelationship arg2 ;
53366 void *argp1 = 0 ;
53367 int res1 = 0 ;
53368 int val2 ;
53369 int ecode2 = 0 ;
53370 PyObject * obj0 = 0 ;
53371 PyObject * obj1 = 0 ;
53372 char * kwnames[] = {
53373 (char *) "self",(char *) "r", NULL
53374 };
53375
53376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53378 if (!SWIG_IsOK(res1)) {
53379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53380 }
53381 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53382 ecode2 = SWIG_AsVal_int(obj1, &val2);
53383 if (!SWIG_IsOK(ecode2)) {
53384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53385 }
53386 arg2 = static_cast< wxRelationship >(val2);
53387 {
53388 PyThreadState* __tstate = wxPyBeginAllowThreads();
53389 (arg1)->SetRelationship(arg2);
53390 wxPyEndAllowThreads(__tstate);
53391 if (PyErr_Occurred()) SWIG_fail;
53392 }
53393 resultobj = SWIG_Py_Void();
53394 return resultobj;
53395 fail:
53396 return NULL;
53397 }
53398
53399
53400 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53401 PyObject *resultobj = 0;
53402 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53403 wxWindow *arg2 = (wxWindow *) 0 ;
53404 bool result;
53405 void *argp1 = 0 ;
53406 int res1 = 0 ;
53407 void *argp2 = 0 ;
53408 int res2 = 0 ;
53409 PyObject * obj0 = 0 ;
53410 PyObject * obj1 = 0 ;
53411 char * kwnames[] = {
53412 (char *) "self",(char *) "otherW", NULL
53413 };
53414
53415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53417 if (!SWIG_IsOK(res1)) {
53418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53419 }
53420 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53422 if (!SWIG_IsOK(res2)) {
53423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53424 }
53425 arg2 = reinterpret_cast< wxWindow * >(argp2);
53426 {
53427 PyThreadState* __tstate = wxPyBeginAllowThreads();
53428 result = (bool)(arg1)->ResetIfWin(arg2);
53429 wxPyEndAllowThreads(__tstate);
53430 if (PyErr_Occurred()) SWIG_fail;
53431 }
53432 {
53433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53434 }
53435 return resultobj;
53436 fail:
53437 return NULL;
53438 }
53439
53440
53441 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53442 PyObject *resultobj = 0;
53443 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53444 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53445 wxWindow *arg3 = (wxWindow *) 0 ;
53446 bool result;
53447 void *argp1 = 0 ;
53448 int res1 = 0 ;
53449 void *argp2 = 0 ;
53450 int res2 = 0 ;
53451 void *argp3 = 0 ;
53452 int res3 = 0 ;
53453 PyObject * obj0 = 0 ;
53454 PyObject * obj1 = 0 ;
53455 PyObject * obj2 = 0 ;
53456 char * kwnames[] = {
53457 (char *) "self",(char *) "constraints",(char *) "win", NULL
53458 };
53459
53460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53462 if (!SWIG_IsOK(res1)) {
53463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53464 }
53465 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53467 if (!SWIG_IsOK(res2)) {
53468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53469 }
53470 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53471 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53472 if (!SWIG_IsOK(res3)) {
53473 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53474 }
53475 arg3 = reinterpret_cast< wxWindow * >(argp3);
53476 {
53477 PyThreadState* __tstate = wxPyBeginAllowThreads();
53478 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53479 wxPyEndAllowThreads(__tstate);
53480 if (PyErr_Occurred()) SWIG_fail;
53481 }
53482 {
53483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53484 }
53485 return resultobj;
53486 fail:
53487 return NULL;
53488 }
53489
53490
53491 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53492 PyObject *resultobj = 0;
53493 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53494 wxEdge arg2 ;
53495 wxWindow *arg3 = (wxWindow *) 0 ;
53496 wxWindow *arg4 = (wxWindow *) 0 ;
53497 int result;
53498 void *argp1 = 0 ;
53499 int res1 = 0 ;
53500 int val2 ;
53501 int ecode2 = 0 ;
53502 void *argp3 = 0 ;
53503 int res3 = 0 ;
53504 void *argp4 = 0 ;
53505 int res4 = 0 ;
53506 PyObject * obj0 = 0 ;
53507 PyObject * obj1 = 0 ;
53508 PyObject * obj2 = 0 ;
53509 PyObject * obj3 = 0 ;
53510 char * kwnames[] = {
53511 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53512 };
53513
53514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53516 if (!SWIG_IsOK(res1)) {
53517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53518 }
53519 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53520 ecode2 = SWIG_AsVal_int(obj1, &val2);
53521 if (!SWIG_IsOK(ecode2)) {
53522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53523 }
53524 arg2 = static_cast< wxEdge >(val2);
53525 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53526 if (!SWIG_IsOK(res3)) {
53527 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53528 }
53529 arg3 = reinterpret_cast< wxWindow * >(argp3);
53530 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53531 if (!SWIG_IsOK(res4)) {
53532 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53533 }
53534 arg4 = reinterpret_cast< wxWindow * >(argp4);
53535 {
53536 PyThreadState* __tstate = wxPyBeginAllowThreads();
53537 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53538 wxPyEndAllowThreads(__tstate);
53539 if (PyErr_Occurred()) SWIG_fail;
53540 }
53541 resultobj = SWIG_From_int(static_cast< int >(result));
53542 return resultobj;
53543 fail:
53544 return NULL;
53545 }
53546
53547
53548 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53549 PyObject *obj;
53550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53551 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53552 return SWIG_Py_Void();
53553 }
53554
53555 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53556 PyObject *resultobj = 0;
53557 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53558 wxIndividualLayoutConstraint *result = 0 ;
53559 void *argp1 = 0 ;
53560 int res1 = 0 ;
53561 PyObject *swig_obj[1] ;
53562
53563 if (!args) SWIG_fail;
53564 swig_obj[0] = args;
53565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53566 if (!SWIG_IsOK(res1)) {
53567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53568 }
53569 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53570 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53572 return resultobj;
53573 fail:
53574 return NULL;
53575 }
53576
53577
53578 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53579 PyObject *resultobj = 0;
53580 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53581 wxIndividualLayoutConstraint *result = 0 ;
53582 void *argp1 = 0 ;
53583 int res1 = 0 ;
53584 PyObject *swig_obj[1] ;
53585
53586 if (!args) SWIG_fail;
53587 swig_obj[0] = args;
53588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53589 if (!SWIG_IsOK(res1)) {
53590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53591 }
53592 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53593 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53595 return resultobj;
53596 fail:
53597 return NULL;
53598 }
53599
53600
53601 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53602 PyObject *resultobj = 0;
53603 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53604 wxIndividualLayoutConstraint *result = 0 ;
53605 void *argp1 = 0 ;
53606 int res1 = 0 ;
53607 PyObject *swig_obj[1] ;
53608
53609 if (!args) SWIG_fail;
53610 swig_obj[0] = args;
53611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53612 if (!SWIG_IsOK(res1)) {
53613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53614 }
53615 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53616 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53618 return resultobj;
53619 fail:
53620 return NULL;
53621 }
53622
53623
53624 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53625 PyObject *resultobj = 0;
53626 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53627 wxIndividualLayoutConstraint *result = 0 ;
53628 void *argp1 = 0 ;
53629 int res1 = 0 ;
53630 PyObject *swig_obj[1] ;
53631
53632 if (!args) SWIG_fail;
53633 swig_obj[0] = args;
53634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53635 if (!SWIG_IsOK(res1)) {
53636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53637 }
53638 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53639 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53641 return resultobj;
53642 fail:
53643 return NULL;
53644 }
53645
53646
53647 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53648 PyObject *resultobj = 0;
53649 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53650 wxIndividualLayoutConstraint *result = 0 ;
53651 void *argp1 = 0 ;
53652 int res1 = 0 ;
53653 PyObject *swig_obj[1] ;
53654
53655 if (!args) SWIG_fail;
53656 swig_obj[0] = args;
53657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53658 if (!SWIG_IsOK(res1)) {
53659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53660 }
53661 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53662 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53664 return resultobj;
53665 fail:
53666 return NULL;
53667 }
53668
53669
53670 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53671 PyObject *resultobj = 0;
53672 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53673 wxIndividualLayoutConstraint *result = 0 ;
53674 void *argp1 = 0 ;
53675 int res1 = 0 ;
53676 PyObject *swig_obj[1] ;
53677
53678 if (!args) SWIG_fail;
53679 swig_obj[0] = args;
53680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53681 if (!SWIG_IsOK(res1)) {
53682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53683 }
53684 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53685 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53687 return resultobj;
53688 fail:
53689 return NULL;
53690 }
53691
53692
53693 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53694 PyObject *resultobj = 0;
53695 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53696 wxIndividualLayoutConstraint *result = 0 ;
53697 void *argp1 = 0 ;
53698 int res1 = 0 ;
53699 PyObject *swig_obj[1] ;
53700
53701 if (!args) SWIG_fail;
53702 swig_obj[0] = args;
53703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53704 if (!SWIG_IsOK(res1)) {
53705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53706 }
53707 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53708 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53710 return resultobj;
53711 fail:
53712 return NULL;
53713 }
53714
53715
53716 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53717 PyObject *resultobj = 0;
53718 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53719 wxIndividualLayoutConstraint *result = 0 ;
53720 void *argp1 = 0 ;
53721 int res1 = 0 ;
53722 PyObject *swig_obj[1] ;
53723
53724 if (!args) SWIG_fail;
53725 swig_obj[0] = args;
53726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53727 if (!SWIG_IsOK(res1)) {
53728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53729 }
53730 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53731 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53733 return resultobj;
53734 fail:
53735 return NULL;
53736 }
53737
53738
53739 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53740 PyObject *resultobj = 0;
53741 wxLayoutConstraints *result = 0 ;
53742
53743 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53744 {
53745 PyThreadState* __tstate = wxPyBeginAllowThreads();
53746 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53747 wxPyEndAllowThreads(__tstate);
53748 if (PyErr_Occurred()) SWIG_fail;
53749 }
53750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53751 return resultobj;
53752 fail:
53753 return NULL;
53754 }
53755
53756
53757 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53758 PyObject *resultobj = 0;
53759 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53760 void *argp1 = 0 ;
53761 int res1 = 0 ;
53762 PyObject *swig_obj[1] ;
53763
53764 if (!args) SWIG_fail;
53765 swig_obj[0] = args;
53766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53767 if (!SWIG_IsOK(res1)) {
53768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53769 }
53770 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53771 {
53772 PyThreadState* __tstate = wxPyBeginAllowThreads();
53773 delete arg1;
53774
53775 wxPyEndAllowThreads(__tstate);
53776 if (PyErr_Occurred()) SWIG_fail;
53777 }
53778 resultobj = SWIG_Py_Void();
53779 return resultobj;
53780 fail:
53781 return NULL;
53782 }
53783
53784
53785 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53786 PyObject *resultobj = 0;
53787 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53788 wxWindow *arg2 = (wxWindow *) 0 ;
53789 int *arg3 = (int *) 0 ;
53790 bool result;
53791 void *argp1 = 0 ;
53792 int res1 = 0 ;
53793 void *argp2 = 0 ;
53794 int res2 = 0 ;
53795 int temp3 ;
53796 int res3 = SWIG_TMPOBJ ;
53797 PyObject * obj0 = 0 ;
53798 PyObject * obj1 = 0 ;
53799 char * kwnames[] = {
53800 (char *) "self",(char *) "win", NULL
53801 };
53802
53803 arg3 = &temp3;
53804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53806 if (!SWIG_IsOK(res1)) {
53807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53808 }
53809 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53810 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53811 if (!SWIG_IsOK(res2)) {
53812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53813 }
53814 arg2 = reinterpret_cast< wxWindow * >(argp2);
53815 {
53816 PyThreadState* __tstate = wxPyBeginAllowThreads();
53817 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53818 wxPyEndAllowThreads(__tstate);
53819 if (PyErr_Occurred()) SWIG_fail;
53820 }
53821 {
53822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53823 }
53824 if (SWIG_IsTmpObj(res3)) {
53825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53826 } else {
53827 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53829 }
53830 return resultobj;
53831 fail:
53832 return NULL;
53833 }
53834
53835
53836 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53837 PyObject *resultobj = 0;
53838 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53839 bool result;
53840 void *argp1 = 0 ;
53841 int res1 = 0 ;
53842 PyObject *swig_obj[1] ;
53843
53844 if (!args) SWIG_fail;
53845 swig_obj[0] = args;
53846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53847 if (!SWIG_IsOK(res1)) {
53848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53849 }
53850 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53851 {
53852 PyThreadState* __tstate = wxPyBeginAllowThreads();
53853 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53854 wxPyEndAllowThreads(__tstate);
53855 if (PyErr_Occurred()) SWIG_fail;
53856 }
53857 {
53858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53859 }
53860 return resultobj;
53861 fail:
53862 return NULL;
53863 }
53864
53865
53866 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53867 PyObject *obj;
53868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53869 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53870 return SWIG_Py_Void();
53871 }
53872
53873 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53874 return SWIG_Python_InitShadowInstance(args);
53875 }
53876
53877 static PyMethodDef SwigMethods[] = {
53878 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53879 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53880 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53881 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53882 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53883 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53884 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53885 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53886 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53888 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53899 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53900 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53901 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53903 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53904 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53905 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53906 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53907 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53908 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53909 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53911 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53917 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53918 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53919 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53920 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53921 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53922 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53923 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53925 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53933 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53934 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53935 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53940 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53941 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53943 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53945 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53947 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53949 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53951 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53953 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53954 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53956 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
53958 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
53960 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53962 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53963 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53964 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53965 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53985 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53986 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53987 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53988 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53989 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53990 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53991 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53992 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53994 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53995 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53996 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54001 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54002 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54003 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54004 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54011 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54018 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54019 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54020 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54021 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54023 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54024 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54025 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54027 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54028 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54029 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54030 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54035 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54036 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54037 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54038 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54039 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54040 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54043 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54044 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54045 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54047 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54048 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54050 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54051 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54052 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54053 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54054 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54055 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54056 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54057 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54058 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54059 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54060 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54061 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54066 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54072 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54073 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54074 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54075 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54077 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54080 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54083 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54086 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54087 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54088 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54091 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54092 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54093 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54097 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54098 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54099 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54103 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54108 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54109 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54110 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54111 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54112 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54113 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54114 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54121 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54122 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54124 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54125 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54126 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54132 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54133 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54135 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54136 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54137 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54138 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54139 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54140 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54141 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54142 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54144 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54145 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54146 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54147 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54148 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54149 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54150 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54151 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54153 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54162 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54174 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54175 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54190 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54191 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54192 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54193 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54196 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54198 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54200 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54202 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54204 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54207 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54208 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54209 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54210 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54212 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54229 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54230 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54236 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54237 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54239 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54240 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54241 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54242 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54243 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54244 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54245 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54246 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54247 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54248 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54249 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54250 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54251 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54252 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54253 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54254 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54255 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54256 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54257 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54258 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54259 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54260 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54261 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54262 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54263 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54264 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54265 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54266 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54267 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54268 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54269 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54270 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54271 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54273 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54274 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54275 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54276 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54279 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54283 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54287 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54288 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54289 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54290 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54291 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54292 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54293 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54295 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54297 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54299 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54301 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54302 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54303 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54305 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54306 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54308 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54309 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54310 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54312 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54313 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54314 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54316 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54318 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54319 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54320 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54322 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54324 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54325 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54327 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54328 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54329 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54331 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54332 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54333 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54334 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54335 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54337 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54338 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54341 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54342 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54344 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54345 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54348 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54349 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54351 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54357 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54358 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54359 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54360 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54361 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54362 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54363 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54364 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54365 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54366 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54367 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54368 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54369 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54370 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54371 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54372 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54373 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54374 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54375 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54376 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54377 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54378 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54379 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54380 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54382 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54383 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54384 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54385 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54386 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54387 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54388 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54389 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54390 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54391 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54392 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54393 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54394 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54395 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54396 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54397 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54398 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54399 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54400 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54401 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54402 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54403 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54404 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54405 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54406 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54407 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54408 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54409 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54410 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54411 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54412 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54413 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54415 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54416 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54418 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54419 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54420 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54421 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54423 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54424 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54425 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54426 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54427 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54428 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54429 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54430 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54431 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54433 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54434 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54435 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54436 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54437 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54438 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54439 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54440 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54441 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54442 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54443 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54444 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54445 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54446 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54447 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54448 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54449 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54450 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54451 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54452 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54453 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54454 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54455 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54456 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54457 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54458 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54459 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54460 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54462 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54463 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54466 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54467 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54468 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54469 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54470 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54471 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54473 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54474 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54477 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54478 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54480 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54481 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54483 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54484 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54486 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54487 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54488 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54490 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54492 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54493 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54495 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54496 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54497 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54499 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54500 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54501 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54503 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54504 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54506 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54507 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54508 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54509 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54510 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54513 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54515 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54517 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54518 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54519 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54520 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54522 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54523 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54524 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54526 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54527 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54528 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54529 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54530 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54531 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54532 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54533 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54534 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54535 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54537 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54538 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54539 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54540 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54541 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54542 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54543 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54544 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54547 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54550 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54552 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54553 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54554 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54555 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54556 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54557 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54558 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54559 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54561 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54562 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54563 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54564 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54565 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54566 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54567 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54568 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54569 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54572 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54573 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54574 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54577 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54578 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54579 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54580 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54581 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54583 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54585 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54588 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54590 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54591 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54593 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54594 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54595 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54597 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54598 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54599 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54601 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54603 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54604 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54605 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54607 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54609 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54611 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54612 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54614 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54615 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54617 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54619 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54620 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54621 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54623 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54625 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54626 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54627 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54629 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54631 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54632 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54633 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54634 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54636 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54638 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54640 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54642 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54643 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54645 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54646 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54647 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54648 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54649 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54650 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54651 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54652 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54653 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54655 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54656 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54657 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54659 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54661 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54663 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54665 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54666 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54667 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54668 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54669 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54670 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54675 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54676 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54677 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54678 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54679 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54680 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54681 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54682 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54683 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54684 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54685 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54687 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54688 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54689 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54690 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54691 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54692 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54693 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54695 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54696 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54697 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54698 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54700 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54701 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54702 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54703 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54704 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54705 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54707 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54710 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54711 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54712 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54713 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54714 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54715 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54716 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54717 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54719 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54720 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54721 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54722 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54724 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54725 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54726 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54727 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54728 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54729 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54730 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54731 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54732 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54733 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54735 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54738 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54739 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54740 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54742 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54744 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54746 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54748 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54749 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54751 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54752 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54754 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54762 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54763 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54767 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54768 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54769 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54770 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54771 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54772 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54773 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54774 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54775 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54776 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54777 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54778 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54779 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54780 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54781 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54783 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54784 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54786 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54787 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54788 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54793 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54794 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54795 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54797 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54798 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54799 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54800 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54803 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54804 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54805 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54807 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54809 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54810 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54811 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54812 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54814 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54816 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54817 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54818 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54820 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54821 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54822 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54823 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54824 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54825 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54826 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54830 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54831 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54832 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54833 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54840 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54844 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54845 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54846 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54847 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54848 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54849 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54850 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54852 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54862 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54863 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54864 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54865 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54868 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54869 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54870 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54871 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54872 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54874 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54875 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54879 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54885 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54886 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54887 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54888 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54890 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54891 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54893 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54896 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54898 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54899 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54900 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54903 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54909 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54913 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54914 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54916 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54925 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54927 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54928 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54929 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54930 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54934 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54935 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54937 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54939 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54942 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54944 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54945 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54946 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54947 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54948 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54950 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54951 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54952 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54953 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54955 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54956 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54957 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54961 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54962 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54963 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54965 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54966 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54967 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54969 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54971 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54972 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54973 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54975 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54976 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54979 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54982 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54987 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54992 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54994 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55002 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55005 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55006 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55017 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55019 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55021 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55023 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55024 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55026 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55028 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55029 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55031 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55032 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55033 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55037 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55044 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55052 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55053 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55054 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55056 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55057 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55059 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55060 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55062 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55063 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55064 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55066 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55067 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55070 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55071 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55073 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55074 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55076 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55077 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55078 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55079 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55080 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55082 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55084 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55086 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55087 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55089 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55090 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55093 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55095 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55097 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55099 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55102 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55104 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55105 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55106 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55108 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55109 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55110 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55112 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55114 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55115 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
55117 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55119 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55120 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55124 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55128 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55129 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55130 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55131 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55132 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55133 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55135 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55137 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55139 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55140 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55141 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55142 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55146 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55147 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55148 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55149 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55151 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55152 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55155 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55157 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55158 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55159 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55160 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55161 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55163 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55164 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55165 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55167 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55168 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55170 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55172 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55173 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55174 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55175 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55176 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55177 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55179 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55180 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55181 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55192 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55193 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55194 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55200 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55201 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55202 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55203 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55204 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55205 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55211 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55212 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55213 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55216 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55217 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55218 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55219 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55220 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55222 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55223 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55224 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55225 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55226 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55227 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55228 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55229 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55230 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55231 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55232 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55234 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55235 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55236 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55237 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55238 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55239 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55240 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55241 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55242 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55243 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55244 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55247 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55248 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55249 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55250 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55251 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55252 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55253 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55254 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55255 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55256 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55260 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55261 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55262 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55263 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55264 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55265 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55266 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55268 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55269 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55270 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55275 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55276 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55277 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55278 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55280 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55281 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55282 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55288 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55289 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55290 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55291 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55292 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55294 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55295 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55296 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55297 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55300 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55302 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55303 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55305 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55306 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55307 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55308 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55311 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55313 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55314 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55315 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55316 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55317 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55319 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55322 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55323 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55325 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55326 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55332 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55333 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55334 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55335 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55338 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55339 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55340 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55341 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55342 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55343 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55345 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55346 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55348 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55350 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55351 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55352 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55353 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55354 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55355 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55356 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55357 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55358 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55359 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55360 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55362 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55363 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55364 { NULL, NULL, 0, NULL }
55365 };
55366
55367
55368 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55369
55370 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55371 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55372 }
55373 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55374 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55375 }
55376 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55377 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55378 }
55379 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55380 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55381 }
55382 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55383 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55384 }
55385 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55386 return (void *)((wxSizer *) ((wxGridSizer *) x));
55387 }
55388 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55389 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55390 }
55391 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55392 return (void *)((wxSizer *) ((wxPySizer *) x));
55393 }
55394 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55395 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55396 }
55397 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55398 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55399 }
55400 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55401 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55402 }
55403 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55404 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55405 }
55406 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55407 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55408 }
55409 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55410 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55411 }
55412 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55413 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55414 }
55415 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55416 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55417 }
55418 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55419 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55420 }
55421 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55422 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55423 }
55424 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55425 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55426 }
55427 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55428 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55429 }
55430 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55431 return (void *)((wxEvent *) ((wxPyEvent *) x));
55432 }
55433 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55434 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55435 }
55436 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55437 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55438 }
55439 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55440 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55441 }
55442 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55443 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55444 }
55445 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55446 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55447 }
55448 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55449 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55450 }
55451 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55452 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55453 }
55454 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55455 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55456 }
55457 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55458 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55459 }
55460 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55461 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55462 }
55463 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55464 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55465 }
55466 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55467 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55468 }
55469 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55470 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55471 }
55472 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55473 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55474 }
55475 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55476 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55477 }
55478 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55479 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55480 }
55481 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55482 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55483 }
55484 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55485 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55486 }
55487 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55488 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55489 }
55490 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55491 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55492 }
55493 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55494 return (void *)((wxEvent *) ((wxShowEvent *) x));
55495 }
55496 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55497 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55498 }
55499 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55500 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55501 }
55502 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55503 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55504 }
55505 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55506 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55507 }
55508 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55509 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55510 }
55511 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55512 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55513 }
55514 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55515 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55516 }
55517 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55518 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55519 }
55520 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55521 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55522 }
55523 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55524 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55525 }
55526 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55527 return (void *)((wxControl *) ((wxControlWithItems *) x));
55528 }
55529 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55530 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55531 }
55532 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55533 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55534 }
55535 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55536 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55537 }
55538 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55539 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55540 }
55541 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55542 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55543 }
55544 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55545 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55546 }
55547 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55548 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55549 }
55550 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55551 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55552 }
55553 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55554 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55555 }
55556 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55557 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55558 }
55559 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55560 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55561 }
55562 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55563 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55564 }
55565 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55566 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55567 }
55568 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55569 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55570 }
55571 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55572 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55573 }
55574 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55575 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55576 }
55577 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55578 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55579 }
55580 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55581 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55582 }
55583 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55584 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55585 }
55586 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55587 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55588 }
55589 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55590 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55591 }
55592 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55593 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55594 }
55595 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55596 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55597 }
55598 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55599 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55600 }
55601 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55602 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55603 }
55604 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55605 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55606 }
55607 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55608 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55609 }
55610 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55611 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55612 }
55613 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55614 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55615 }
55616 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55617 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55618 }
55619 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55620 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55621 }
55622 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55623 return (void *)((wxObject *) ((wxSizerItem *) x));
55624 }
55625 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55626 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55627 }
55628 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55629 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55630 }
55631 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55632 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55633 }
55634 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55635 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55636 }
55637 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55638 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55639 }
55640 static void *_p_wxSizerTo_p_wxObject(void *x) {
55641 return (void *)((wxObject *) ((wxSizer *) x));
55642 }
55643 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55644 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55645 }
55646 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55647 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55648 }
55649 static void *_p_wxEventTo_p_wxObject(void *x) {
55650 return (void *)((wxObject *) ((wxEvent *) x));
55651 }
55652 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55653 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55654 }
55655 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55656 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55657 }
55658 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55659 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55660 }
55661 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55662 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55663 }
55664 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55665 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55666 }
55667 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55668 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55669 }
55670 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55671 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55672 }
55673 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55674 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55675 }
55676 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55677 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55678 }
55679 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55680 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55681 }
55682 static void *_p_wxControlTo_p_wxObject(void *x) {
55683 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55684 }
55685 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55686 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55687 }
55688 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55689 return (void *)((wxObject *) ((wxFSFile *) x));
55690 }
55691 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55692 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55693 }
55694 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55695 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55696 }
55697 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55698 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55699 }
55700 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55701 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55702 }
55703 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55704 return (void *)((wxObject *) ((wxMenuItem *) x));
55705 }
55706 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55707 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55708 }
55709 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55710 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55711 }
55712 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55713 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55714 }
55715 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55716 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55717 }
55718 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55719 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55720 }
55721 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55722 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55723 }
55724 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55725 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55726 }
55727 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55728 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55729 }
55730 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55731 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55732 }
55733 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55734 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55735 }
55736 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55737 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55738 }
55739 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55740 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55741 }
55742 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55743 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55744 }
55745 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55746 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55747 }
55748 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55749 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55750 }
55751 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55752 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55753 }
55754 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55755 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55756 }
55757 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55758 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55759 }
55760 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55761 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55762 }
55763 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55764 return (void *)((wxObject *) ((wxImageHandler *) x));
55765 }
55766 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55767 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55768 }
55769 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55770 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55771 }
55772 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55773 return (void *)((wxObject *) ((wxEvtHandler *) x));
55774 }
55775 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55776 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55777 }
55778 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55779 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55780 }
55781 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55782 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55783 }
55784 static void *_p_wxImageTo_p_wxObject(void *x) {
55785 return (void *)((wxObject *) ((wxImage *) x));
55786 }
55787 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55788 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55789 }
55790 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55791 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55792 }
55793 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55794 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55795 }
55796 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55797 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55798 }
55799 static void *_p_wxWindowTo_p_wxObject(void *x) {
55800 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55801 }
55802 static void *_p_wxMenuTo_p_wxObject(void *x) {
55803 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55804 }
55805 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55806 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55807 }
55808 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55809 return (void *)((wxObject *) ((wxFileSystem *) x));
55810 }
55811 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55812 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55813 }
55814 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55815 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55816 }
55817 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55818 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55819 }
55820 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55821 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55822 }
55823 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55824 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55825 }
55826 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55827 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55828 }
55829 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55830 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55831 }
55832 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55833 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55834 }
55835 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55836 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55837 }
55838 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55839 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55840 }
55841 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55842 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55843 }
55844 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55845 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55846 }
55847 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55848 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55849 }
55850 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55851 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55852 }
55853 static void *_p_wxControlTo_p_wxWindow(void *x) {
55854 return (void *)((wxWindow *) ((wxControl *) x));
55855 }
55856 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55857 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55858 }
55859 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55860 return (void *)((wxWindow *) ((wxMenuBar *) x));
55861 }
55862 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55863 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55864 }
55865 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55866 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55867 }
55868 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55869 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55870 }
55871 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55872 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55873 }
55874 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55875 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55876 }
55877 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55878 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55879 }
55880 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55881 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55882 }
55883 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55884 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55885 }
55886 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55887 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55888 }
55889 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55890 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55891 }
55892 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55893 return (void *)((wxValidator *) ((wxPyValidator *) x));
55894 }
55895 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55896 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55897 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};
55898 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55899 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55900 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55901 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55902 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55903 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55904 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55905 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55906 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55907 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55908 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55909 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55910 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55911 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55912 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55913 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55914 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55915 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55916 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55917 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55918 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55919 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55920 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55921 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55922 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55923 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55924 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55925 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55926 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55927 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55928 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55929 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55930 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55931 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55932 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55933 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55934 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55935 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55936 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55937 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55938 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55939 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55940 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55941 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55942 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55943 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55944 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55945 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55946 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55947 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55948 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55949 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55950 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55951 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55952 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55953 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55954 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55955 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55956 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55957 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55958 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55959 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55960 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55961 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55962 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55963 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55964 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55965 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55966 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55967 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55968 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55969 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55970 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55971 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55972 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55973 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55974 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55975 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55976 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55977 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55978 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55979 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55980 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55981 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55982 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55983 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55984 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55985 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55986 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55987 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55988 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55989 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55990 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55991 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55992 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55993 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55994 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55995 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55996 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55997 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55998 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55999 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56000 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56001 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56002 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56003 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56004 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56005 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56006 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56007 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56008 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56009 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56010 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56011 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56012 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56013 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56014 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56015 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56016 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56017 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56018 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56019 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56020 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56021 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56022 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56023 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56024 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56025 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56026 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56027
56028 static swig_type_info *swig_type_initial[] = {
56029 &_swigt__p_buffer,
56030 &_swigt__p_char,
56031 &_swigt__p_form_ops_t,
56032 &_swigt__p_int,
56033 &_swigt__p_long,
56034 &_swigt__p_unsigned_char,
56035 &_swigt__p_unsigned_int,
56036 &_swigt__p_unsigned_long,
56037 &_swigt__p_wxANIHandler,
56038 &_swigt__p_wxAcceleratorEntry,
56039 &_swigt__p_wxAcceleratorTable,
56040 &_swigt__p_wxActivateEvent,
56041 &_swigt__p_wxAppTraits,
56042 &_swigt__p_wxArrayString,
56043 &_swigt__p_wxBMPHandler,
56044 &_swigt__p_wxBitmap,
56045 &_swigt__p_wxBoxSizer,
56046 &_swigt__p_wxButton,
56047 &_swigt__p_wxCURHandler,
56048 &_swigt__p_wxCaret,
56049 &_swigt__p_wxChildFocusEvent,
56050 &_swigt__p_wxClipboardTextEvent,
56051 &_swigt__p_wxCloseEvent,
56052 &_swigt__p_wxColour,
56053 &_swigt__p_wxCommandEvent,
56054 &_swigt__p_wxContextMenuEvent,
56055 &_swigt__p_wxControl,
56056 &_swigt__p_wxControlWithItems,
56057 &_swigt__p_wxCursor,
56058 &_swigt__p_wxDC,
56059 &_swigt__p_wxDateEvent,
56060 &_swigt__p_wxDateTime,
56061 &_swigt__p_wxDisplayChangedEvent,
56062 &_swigt__p_wxDropFilesEvent,
56063 &_swigt__p_wxDuplexMode,
56064 &_swigt__p_wxEraseEvent,
56065 &_swigt__p_wxEvent,
56066 &_swigt__p_wxEventLoop,
56067 &_swigt__p_wxEventLoopActivator,
56068 &_swigt__p_wxEvtHandler,
56069 &_swigt__p_wxFSFile,
56070 &_swigt__p_wxFileSystem,
56071 &_swigt__p_wxFileSystemHandler,
56072 &_swigt__p_wxFlexGridSizer,
56073 &_swigt__p_wxFocusEvent,
56074 &_swigt__p_wxFont,
56075 &_swigt__p_wxFrame,
56076 &_swigt__p_wxGBPosition,
56077 &_swigt__p_wxGBSizerItem,
56078 &_swigt__p_wxGBSpan,
56079 &_swigt__p_wxGIFHandler,
56080 &_swigt__p_wxGridBagSizer,
56081 &_swigt__p_wxGridSizer,
56082 &_swigt__p_wxHelpEvent__Origin,
56083 &_swigt__p_wxICOHandler,
56084 &_swigt__p_wxIconizeEvent,
56085 &_swigt__p_wxIdleEvent,
56086 &_swigt__p_wxImage,
56087 &_swigt__p_wxImageHandler,
56088 &_swigt__p_wxImageHistogram,
56089 &_swigt__p_wxImage_HSVValue,
56090 &_swigt__p_wxImage_RGBValue,
56091 &_swigt__p_wxIndividualLayoutConstraint,
56092 &_swigt__p_wxInitDialogEvent,
56093 &_swigt__p_wxInputStream,
56094 &_swigt__p_wxInternetFSHandler,
56095 &_swigt__p_wxItemContainer,
56096 &_swigt__p_wxJPEGHandler,
56097 &_swigt__p_wxKeyEvent,
56098 &_swigt__p_wxLayoutConstraints,
56099 &_swigt__p_wxMaximizeEvent,
56100 &_swigt__p_wxMemoryFSHandler,
56101 &_swigt__p_wxMenu,
56102 &_swigt__p_wxMenuBar,
56103 &_swigt__p_wxMenuBarBase,
56104 &_swigt__p_wxMenuEvent,
56105 &_swigt__p_wxMenuItem,
56106 &_swigt__p_wxMouseCaptureChangedEvent,
56107 &_swigt__p_wxMouseCaptureLostEvent,
56108 &_swigt__p_wxMouseEvent,
56109 &_swigt__p_wxMoveEvent,
56110 &_swigt__p_wxNavigationKeyEvent,
56111 &_swigt__p_wxNcPaintEvent,
56112 &_swigt__p_wxNotifyEvent,
56113 &_swigt__p_wxObject,
56114 &_swigt__p_wxOutputStream,
56115 &_swigt__p_wxPCXHandler,
56116 &_swigt__p_wxPNGHandler,
56117 &_swigt__p_wxPNMHandler,
56118 &_swigt__p_wxPaintEvent,
56119 &_swigt__p_wxPaletteChangedEvent,
56120 &_swigt__p_wxPaperSize,
56121 &_swigt__p_wxPoint,
56122 &_swigt__p_wxPoint2D,
56123 &_swigt__p_wxPropagateOnce,
56124 &_swigt__p_wxPropagationDisabler,
56125 &_swigt__p_wxPyApp,
56126 &_swigt__p_wxPyCommandEvent,
56127 &_swigt__p_wxPyDropTarget,
56128 &_swigt__p_wxPyEvent,
56129 &_swigt__p_wxPyFileSystemHandler,
56130 &_swigt__p_wxPyImageHandler,
56131 &_swigt__p_wxPyInputStream,
56132 &_swigt__p_wxPySizer,
56133 &_swigt__p_wxPyValidator,
56134 &_swigt__p_wxQuantize,
56135 &_swigt__p_wxQueryNewPaletteEvent,
56136 &_swigt__p_wxRealPoint,
56137 &_swigt__p_wxRect,
56138 &_swigt__p_wxRegion,
56139 &_swigt__p_wxScrollEvent,
56140 &_swigt__p_wxScrollWinEvent,
56141 &_swigt__p_wxSetCursorEvent,
56142 &_swigt__p_wxShowEvent,
56143 &_swigt__p_wxSize,
56144 &_swigt__p_wxSizeEvent,
56145 &_swigt__p_wxSizer,
56146 &_swigt__p_wxSizerItem,
56147 &_swigt__p_wxStaticBox,
56148 &_swigt__p_wxStaticBoxSizer,
56149 &_swigt__p_wxStdDialogButtonSizer,
56150 &_swigt__p_wxSysColourChangedEvent,
56151 &_swigt__p_wxTIFFHandler,
56152 &_swigt__p_wxToolTip,
56153 &_swigt__p_wxUpdateUIEvent,
56154 &_swigt__p_wxValidator,
56155 &_swigt__p_wxVisualAttributes,
56156 &_swigt__p_wxWindow,
56157 &_swigt__p_wxWindowCreateEvent,
56158 &_swigt__p_wxWindowDestroyEvent,
56159 &_swigt__p_wxXPMHandler,
56160 &_swigt__p_wxZipFSHandler,
56161 };
56162
56163 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56164 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56165 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56166 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56167 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56168 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56169 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56170 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56171 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56172 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56173 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56174 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56175 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56176 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56177 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}};
56178 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56179 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}};
56180 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56181 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}};
56182 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56183 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56184 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56185 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56186 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56187 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}};
56188 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56189 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}};
56190 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56191 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56192 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56193 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56194 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56195 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56196 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56197 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56198 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56199 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}};
56200 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56201 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56202 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}};
56203 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56204 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56205 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}};
56206 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}};
56207 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56208 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56209 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56210 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56211 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56212 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56213 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56214 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56215 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}};
56216 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56217 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}};
56218 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56219 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56220 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56221 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}};
56222 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56223 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56224 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56225 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56226 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56227 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56228 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56229 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}};
56230 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56231 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56232 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56233 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56234 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56235 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56236 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56237 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56238 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56239 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56240 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56241 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56242 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56243 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56244 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56245 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56246 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56247 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}};
56248 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56249 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56250 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56251 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56252 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56253 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56254 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56255 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56256 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56257 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56258 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56259 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56260 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56261 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56262 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56263 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56264 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56265 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56266 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56267 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56268 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56269 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56270 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56271 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56272 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56273 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56274 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56275 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56276 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56277 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56278 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56279 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}};
56280 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}};
56281 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56282 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56283 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56284 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56285 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56286 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56287 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56288 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}};
56289 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56290 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}};
56291 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56292 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56293 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56294 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56295
56296 static swig_cast_info *swig_cast_initial[] = {
56297 _swigc__p_buffer,
56298 _swigc__p_char,
56299 _swigc__p_form_ops_t,
56300 _swigc__p_int,
56301 _swigc__p_long,
56302 _swigc__p_unsigned_char,
56303 _swigc__p_unsigned_int,
56304 _swigc__p_unsigned_long,
56305 _swigc__p_wxANIHandler,
56306 _swigc__p_wxAcceleratorEntry,
56307 _swigc__p_wxAcceleratorTable,
56308 _swigc__p_wxActivateEvent,
56309 _swigc__p_wxAppTraits,
56310 _swigc__p_wxArrayString,
56311 _swigc__p_wxBMPHandler,
56312 _swigc__p_wxBitmap,
56313 _swigc__p_wxBoxSizer,
56314 _swigc__p_wxButton,
56315 _swigc__p_wxCURHandler,
56316 _swigc__p_wxCaret,
56317 _swigc__p_wxChildFocusEvent,
56318 _swigc__p_wxClipboardTextEvent,
56319 _swigc__p_wxCloseEvent,
56320 _swigc__p_wxColour,
56321 _swigc__p_wxCommandEvent,
56322 _swigc__p_wxContextMenuEvent,
56323 _swigc__p_wxControl,
56324 _swigc__p_wxControlWithItems,
56325 _swigc__p_wxCursor,
56326 _swigc__p_wxDC,
56327 _swigc__p_wxDateEvent,
56328 _swigc__p_wxDateTime,
56329 _swigc__p_wxDisplayChangedEvent,
56330 _swigc__p_wxDropFilesEvent,
56331 _swigc__p_wxDuplexMode,
56332 _swigc__p_wxEraseEvent,
56333 _swigc__p_wxEvent,
56334 _swigc__p_wxEventLoop,
56335 _swigc__p_wxEventLoopActivator,
56336 _swigc__p_wxEvtHandler,
56337 _swigc__p_wxFSFile,
56338 _swigc__p_wxFileSystem,
56339 _swigc__p_wxFileSystemHandler,
56340 _swigc__p_wxFlexGridSizer,
56341 _swigc__p_wxFocusEvent,
56342 _swigc__p_wxFont,
56343 _swigc__p_wxFrame,
56344 _swigc__p_wxGBPosition,
56345 _swigc__p_wxGBSizerItem,
56346 _swigc__p_wxGBSpan,
56347 _swigc__p_wxGIFHandler,
56348 _swigc__p_wxGridBagSizer,
56349 _swigc__p_wxGridSizer,
56350 _swigc__p_wxHelpEvent__Origin,
56351 _swigc__p_wxICOHandler,
56352 _swigc__p_wxIconizeEvent,
56353 _swigc__p_wxIdleEvent,
56354 _swigc__p_wxImage,
56355 _swigc__p_wxImageHandler,
56356 _swigc__p_wxImageHistogram,
56357 _swigc__p_wxImage_HSVValue,
56358 _swigc__p_wxImage_RGBValue,
56359 _swigc__p_wxIndividualLayoutConstraint,
56360 _swigc__p_wxInitDialogEvent,
56361 _swigc__p_wxInputStream,
56362 _swigc__p_wxInternetFSHandler,
56363 _swigc__p_wxItemContainer,
56364 _swigc__p_wxJPEGHandler,
56365 _swigc__p_wxKeyEvent,
56366 _swigc__p_wxLayoutConstraints,
56367 _swigc__p_wxMaximizeEvent,
56368 _swigc__p_wxMemoryFSHandler,
56369 _swigc__p_wxMenu,
56370 _swigc__p_wxMenuBar,
56371 _swigc__p_wxMenuBarBase,
56372 _swigc__p_wxMenuEvent,
56373 _swigc__p_wxMenuItem,
56374 _swigc__p_wxMouseCaptureChangedEvent,
56375 _swigc__p_wxMouseCaptureLostEvent,
56376 _swigc__p_wxMouseEvent,
56377 _swigc__p_wxMoveEvent,
56378 _swigc__p_wxNavigationKeyEvent,
56379 _swigc__p_wxNcPaintEvent,
56380 _swigc__p_wxNotifyEvent,
56381 _swigc__p_wxObject,
56382 _swigc__p_wxOutputStream,
56383 _swigc__p_wxPCXHandler,
56384 _swigc__p_wxPNGHandler,
56385 _swigc__p_wxPNMHandler,
56386 _swigc__p_wxPaintEvent,
56387 _swigc__p_wxPaletteChangedEvent,
56388 _swigc__p_wxPaperSize,
56389 _swigc__p_wxPoint,
56390 _swigc__p_wxPoint2D,
56391 _swigc__p_wxPropagateOnce,
56392 _swigc__p_wxPropagationDisabler,
56393 _swigc__p_wxPyApp,
56394 _swigc__p_wxPyCommandEvent,
56395 _swigc__p_wxPyDropTarget,
56396 _swigc__p_wxPyEvent,
56397 _swigc__p_wxPyFileSystemHandler,
56398 _swigc__p_wxPyImageHandler,
56399 _swigc__p_wxPyInputStream,
56400 _swigc__p_wxPySizer,
56401 _swigc__p_wxPyValidator,
56402 _swigc__p_wxQuantize,
56403 _swigc__p_wxQueryNewPaletteEvent,
56404 _swigc__p_wxRealPoint,
56405 _swigc__p_wxRect,
56406 _swigc__p_wxRegion,
56407 _swigc__p_wxScrollEvent,
56408 _swigc__p_wxScrollWinEvent,
56409 _swigc__p_wxSetCursorEvent,
56410 _swigc__p_wxShowEvent,
56411 _swigc__p_wxSize,
56412 _swigc__p_wxSizeEvent,
56413 _swigc__p_wxSizer,
56414 _swigc__p_wxSizerItem,
56415 _swigc__p_wxStaticBox,
56416 _swigc__p_wxStaticBoxSizer,
56417 _swigc__p_wxStdDialogButtonSizer,
56418 _swigc__p_wxSysColourChangedEvent,
56419 _swigc__p_wxTIFFHandler,
56420 _swigc__p_wxToolTip,
56421 _swigc__p_wxUpdateUIEvent,
56422 _swigc__p_wxValidator,
56423 _swigc__p_wxVisualAttributes,
56424 _swigc__p_wxWindow,
56425 _swigc__p_wxWindowCreateEvent,
56426 _swigc__p_wxWindowDestroyEvent,
56427 _swigc__p_wxXPMHandler,
56428 _swigc__p_wxZipFSHandler,
56429 };
56430
56431
56432 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56433
56434 static swig_const_info swig_const_table[] = {
56435 {0, 0, 0, 0.0, 0, 0}};
56436
56437 #ifdef __cplusplus
56438 }
56439 #endif
56440 /* -----------------------------------------------------------------------------
56441 * Type initialization:
56442 * This problem is tough by the requirement that no dynamic
56443 * memory is used. Also, since swig_type_info structures store pointers to
56444 * swig_cast_info structures and swig_cast_info structures store pointers back
56445 * to swig_type_info structures, we need some lookup code at initialization.
56446 * The idea is that swig generates all the structures that are needed.
56447 * The runtime then collects these partially filled structures.
56448 * The SWIG_InitializeModule function takes these initial arrays out of
56449 * swig_module, and does all the lookup, filling in the swig_module.types
56450 * array with the correct data and linking the correct swig_cast_info
56451 * structures together.
56452 *
56453 * The generated swig_type_info structures are assigned staticly to an initial
56454 * array. We just loop though that array, and handle each type individually.
56455 * First we lookup if this type has been already loaded, and if so, use the
56456 * loaded structure instead of the generated one. Then we have to fill in the
56457 * cast linked list. The cast data is initially stored in something like a
56458 * two-dimensional array. Each row corresponds to a type (there are the same
56459 * number of rows as there are in the swig_type_initial array). Each entry in
56460 * a column is one of the swig_cast_info structures for that type.
56461 * The cast_initial array is actually an array of arrays, because each row has
56462 * a variable number of columns. So to actually build the cast linked list,
56463 * we find the array of casts associated with the type, and loop through it
56464 * adding the casts to the list. The one last trick we need to do is making
56465 * sure the type pointer in the swig_cast_info struct is correct.
56466 *
56467 * First off, we lookup the cast->type name to see if it is already loaded.
56468 * There are three cases to handle:
56469 * 1) If the cast->type has already been loaded AND the type we are adding
56470 * casting info to has not been loaded (it is in this module), THEN we
56471 * replace the cast->type pointer with the type pointer that has already
56472 * been loaded.
56473 * 2) If BOTH types (the one we are adding casting info to, and the
56474 * cast->type) are loaded, THEN the cast info has already been loaded by
56475 * the previous module so we just ignore it.
56476 * 3) Finally, if cast->type has not already been loaded, then we add that
56477 * swig_cast_info to the linked list (because the cast->type) pointer will
56478 * be correct.
56479 * ----------------------------------------------------------------------------- */
56480
56481 #ifdef __cplusplus
56482 extern "C" {
56483 #if 0
56484 } /* c-mode */
56485 #endif
56486 #endif
56487
56488 #if 0
56489 #define SWIGRUNTIME_DEBUG
56490 #endif
56491
56492 SWIGRUNTIME void
56493 SWIG_InitializeModule(void *clientdata) {
56494 size_t i;
56495 swig_module_info *module_head;
56496 static int init_run = 0;
56497
56498 clientdata = clientdata;
56499
56500 if (init_run) return;
56501 init_run = 1;
56502
56503 /* Initialize the swig_module */
56504 swig_module.type_initial = swig_type_initial;
56505 swig_module.cast_initial = swig_cast_initial;
56506
56507 /* Try and load any already created modules */
56508 module_head = SWIG_GetModule(clientdata);
56509 if (module_head) {
56510 swig_module.next = module_head->next;
56511 module_head->next = &swig_module;
56512 } else {
56513 /* This is the first module loaded */
56514 swig_module.next = &swig_module;
56515 SWIG_SetModule(clientdata, &swig_module);
56516 }
56517
56518 /* Now work on filling in swig_module.types */
56519 #ifdef SWIGRUNTIME_DEBUG
56520 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56521 #endif
56522 for (i = 0; i < swig_module.size; ++i) {
56523 swig_type_info *type = 0;
56524 swig_type_info *ret;
56525 swig_cast_info *cast;
56526
56527 #ifdef SWIGRUNTIME_DEBUG
56528 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56529 #endif
56530
56531 /* if there is another module already loaded */
56532 if (swig_module.next != &swig_module) {
56533 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56534 }
56535 if (type) {
56536 /* Overwrite clientdata field */
56537 #ifdef SWIGRUNTIME_DEBUG
56538 printf("SWIG_InitializeModule: found type %s\n", type->name);
56539 #endif
56540 if (swig_module.type_initial[i]->clientdata) {
56541 type->clientdata = swig_module.type_initial[i]->clientdata;
56542 #ifdef SWIGRUNTIME_DEBUG
56543 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56544 #endif
56545 }
56546 } else {
56547 type = swig_module.type_initial[i];
56548 }
56549
56550 /* Insert casting types */
56551 cast = swig_module.cast_initial[i];
56552 while (cast->type) {
56553 /* Don't need to add information already in the list */
56554 ret = 0;
56555 #ifdef SWIGRUNTIME_DEBUG
56556 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56557 #endif
56558 if (swig_module.next != &swig_module) {
56559 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56560 #ifdef SWIGRUNTIME_DEBUG
56561 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56562 #endif
56563 }
56564 if (ret) {
56565 if (type == swig_module.type_initial[i]) {
56566 #ifdef SWIGRUNTIME_DEBUG
56567 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56568 #endif
56569 cast->type = ret;
56570 ret = 0;
56571 } else {
56572 /* Check for casting already in the list */
56573 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56574 #ifdef SWIGRUNTIME_DEBUG
56575 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56576 #endif
56577 if (!ocast) ret = 0;
56578 }
56579 }
56580
56581 if (!ret) {
56582 #ifdef SWIGRUNTIME_DEBUG
56583 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56584 #endif
56585 if (type->cast) {
56586 type->cast->prev = cast;
56587 cast->next = type->cast;
56588 }
56589 type->cast = cast;
56590 }
56591 cast++;
56592 }
56593 /* Set entry in modules->types array equal to the type */
56594 swig_module.types[i] = type;
56595 }
56596 swig_module.types[i] = 0;
56597
56598 #ifdef SWIGRUNTIME_DEBUG
56599 printf("**** SWIG_InitializeModule: Cast List ******\n");
56600 for (i = 0; i < swig_module.size; ++i) {
56601 int j = 0;
56602 swig_cast_info *cast = swig_module.cast_initial[i];
56603 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56604 while (cast->type) {
56605 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56606 cast++;
56607 ++j;
56608 }
56609 printf("---- Total casts: %d\n",j);
56610 }
56611 printf("**** SWIG_InitializeModule: Cast List ******\n");
56612 #endif
56613 }
56614
56615 /* This function will propagate the clientdata field of type to
56616 * any new swig_type_info structures that have been added into the list
56617 * of equivalent types. It is like calling
56618 * SWIG_TypeClientData(type, clientdata) a second time.
56619 */
56620 SWIGRUNTIME void
56621 SWIG_PropagateClientData(void) {
56622 size_t i;
56623 swig_cast_info *equiv;
56624 static int init_run = 0;
56625
56626 if (init_run) return;
56627 init_run = 1;
56628
56629 for (i = 0; i < swig_module.size; i++) {
56630 if (swig_module.types[i]->clientdata) {
56631 equiv = swig_module.types[i]->cast;
56632 while (equiv) {
56633 if (!equiv->converter) {
56634 if (equiv->type && !equiv->type->clientdata)
56635 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56636 }
56637 equiv = equiv->next;
56638 }
56639 }
56640 }
56641 }
56642
56643 #ifdef __cplusplus
56644 #if 0
56645 {
56646 /* c-mode */
56647 #endif
56648 }
56649 #endif
56650
56651
56652
56653 #ifdef __cplusplus
56654 extern "C" {
56655 #endif
56656
56657 /* Python-specific SWIG API */
56658 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56659 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56660 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56661
56662 /* -----------------------------------------------------------------------------
56663 * global variable support code.
56664 * ----------------------------------------------------------------------------- */
56665
56666 typedef struct swig_globalvar {
56667 char *name; /* Name of global variable */
56668 PyObject *(*get_attr)(void); /* Return the current value */
56669 int (*set_attr)(PyObject *); /* Set the value */
56670 struct swig_globalvar *next;
56671 } swig_globalvar;
56672
56673 typedef struct swig_varlinkobject {
56674 PyObject_HEAD
56675 swig_globalvar *vars;
56676 } swig_varlinkobject;
56677
56678 SWIGINTERN PyObject *
56679 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56680 return PyString_FromString("<Swig global variables>");
56681 }
56682
56683 SWIGINTERN PyObject *
56684 swig_varlink_str(swig_varlinkobject *v) {
56685 PyObject *str = PyString_FromString("(");
56686 swig_globalvar *var;
56687 for (var = v->vars; var; var=var->next) {
56688 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56689 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56690 }
56691 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56692 return str;
56693 }
56694
56695 SWIGINTERN int
56696 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56697 PyObject *str = swig_varlink_str(v);
56698 fprintf(fp,"Swig global variables ");
56699 fprintf(fp,"%s\n", PyString_AsString(str));
56700 Py_DECREF(str);
56701 return 0;
56702 }
56703
56704 SWIGINTERN void
56705 swig_varlink_dealloc(swig_varlinkobject *v) {
56706 swig_globalvar *var = v->vars;
56707 while (var) {
56708 swig_globalvar *n = var->next;
56709 free(var->name);
56710 free(var);
56711 var = n;
56712 }
56713 }
56714
56715 SWIGINTERN PyObject *
56716 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56717 PyObject *res = NULL;
56718 swig_globalvar *var = v->vars;
56719 while (var) {
56720 if (strcmp(var->name,n) == 0) {
56721 res = (*var->get_attr)();
56722 break;
56723 }
56724 var = var->next;
56725 }
56726 if (res == NULL && !PyErr_Occurred()) {
56727 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56728 }
56729 return res;
56730 }
56731
56732 SWIGINTERN int
56733 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56734 int res = 1;
56735 swig_globalvar *var = v->vars;
56736 while (var) {
56737 if (strcmp(var->name,n) == 0) {
56738 res = (*var->set_attr)(p);
56739 break;
56740 }
56741 var = var->next;
56742 }
56743 if (res == 1 && !PyErr_Occurred()) {
56744 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56745 }
56746 return res;
56747 }
56748
56749 SWIGINTERN PyTypeObject*
56750 swig_varlink_type(void) {
56751 static char varlink__doc__[] = "Swig var link object";
56752 static PyTypeObject varlink_type;
56753 static int type_init = 0;
56754 if (!type_init) {
56755 const PyTypeObject tmp
56756 = {
56757 PyObject_HEAD_INIT(NULL)
56758 0, /* Number of items in variable part (ob_size) */
56759 (char *)"swigvarlink", /* Type name (tp_name) */
56760 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56761 0, /* Itemsize (tp_itemsize) */
56762 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56763 (printfunc) swig_varlink_print, /* Print (tp_print) */
56764 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56765 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56766 0, /* tp_compare */
56767 (reprfunc) swig_varlink_repr, /* tp_repr */
56768 0, /* tp_as_number */
56769 0, /* tp_as_sequence */
56770 0, /* tp_as_mapping */
56771 0, /* tp_hash */
56772 0, /* tp_call */
56773 (reprfunc)swig_varlink_str, /* tp_str */
56774 0, /* tp_getattro */
56775 0, /* tp_setattro */
56776 0, /* tp_as_buffer */
56777 0, /* tp_flags */
56778 varlink__doc__, /* tp_doc */
56779 0, /* tp_traverse */
56780 0, /* tp_clear */
56781 0, /* tp_richcompare */
56782 0, /* tp_weaklistoffset */
56783 #if PY_VERSION_HEX >= 0x02020000
56784 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56785 #endif
56786 #if PY_VERSION_HEX >= 0x02030000
56787 0, /* tp_del */
56788 #endif
56789 #ifdef COUNT_ALLOCS
56790 0,0,0,0 /* tp_alloc -> tp_next */
56791 #endif
56792 };
56793 varlink_type = tmp;
56794 varlink_type.ob_type = &PyType_Type;
56795 type_init = 1;
56796 }
56797 return &varlink_type;
56798 }
56799
56800 /* Create a variable linking object for use later */
56801 SWIGINTERN PyObject *
56802 SWIG_Python_newvarlink(void) {
56803 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56804 if (result) {
56805 result->vars = 0;
56806 }
56807 return ((PyObject*) result);
56808 }
56809
56810 SWIGINTERN void
56811 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56812 swig_varlinkobject *v = (swig_varlinkobject *) p;
56813 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56814 if (gv) {
56815 size_t size = strlen(name)+1;
56816 gv->name = (char *)malloc(size);
56817 if (gv->name) {
56818 strncpy(gv->name,name,size);
56819 gv->get_attr = get_attr;
56820 gv->set_attr = set_attr;
56821 gv->next = v->vars;
56822 }
56823 }
56824 v->vars = gv;
56825 }
56826
56827 SWIGINTERN PyObject *
56828 SWIG_globals() {
56829 static PyObject *_SWIG_globals = 0;
56830 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56831 return _SWIG_globals;
56832 }
56833
56834 /* -----------------------------------------------------------------------------
56835 * constants/methods manipulation
56836 * ----------------------------------------------------------------------------- */
56837
56838 /* Install Constants */
56839 SWIGINTERN void
56840 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56841 PyObject *obj = 0;
56842 size_t i;
56843 for (i = 0; constants[i].type; ++i) {
56844 switch(constants[i].type) {
56845 case SWIG_PY_POINTER:
56846 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56847 break;
56848 case SWIG_PY_BINARY:
56849 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56850 break;
56851 default:
56852 obj = 0;
56853 break;
56854 }
56855 if (obj) {
56856 PyDict_SetItemString(d, constants[i].name, obj);
56857 Py_DECREF(obj);
56858 }
56859 }
56860 }
56861
56862 /* -----------------------------------------------------------------------------*/
56863 /* Fix SwigMethods to carry the callback ptrs when needed */
56864 /* -----------------------------------------------------------------------------*/
56865
56866 SWIGINTERN void
56867 SWIG_Python_FixMethods(PyMethodDef *methods,
56868 swig_const_info *const_table,
56869 swig_type_info **types,
56870 swig_type_info **types_initial) {
56871 size_t i;
56872 for (i = 0; methods[i].ml_name; ++i) {
56873 const char *c = methods[i].ml_doc;
56874 if (c && (c = strstr(c, "swig_ptr: "))) {
56875 int j;
56876 swig_const_info *ci = 0;
56877 const char *name = c + 10;
56878 for (j = 0; const_table[j].type; ++j) {
56879 if (strncmp(const_table[j].name, name,
56880 strlen(const_table[j].name)) == 0) {
56881 ci = &(const_table[j]);
56882 break;
56883 }
56884 }
56885 if (ci) {
56886 size_t shift = (ci->ptype) - types;
56887 swig_type_info *ty = types_initial[shift];
56888 size_t ldoc = (c - methods[i].ml_doc);
56889 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56890 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56891 if (ndoc) {
56892 char *buff = ndoc;
56893 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56894 if (ptr) {
56895 strncpy(buff, methods[i].ml_doc, ldoc);
56896 buff += ldoc;
56897 strncpy(buff, "swig_ptr: ", 10);
56898 buff += 10;
56899 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56900 methods[i].ml_doc = ndoc;
56901 }
56902 }
56903 }
56904 }
56905 }
56906 }
56907
56908 #ifdef __cplusplus
56909 }
56910 #endif
56911
56912 /* -----------------------------------------------------------------------------*
56913 * Partial Init method
56914 * -----------------------------------------------------------------------------*/
56915
56916 #ifdef __cplusplus
56917 extern "C"
56918 #endif
56919 SWIGEXPORT void SWIG_init(void) {
56920 PyObject *m, *d;
56921
56922 /* Fix SwigMethods to carry the callback ptrs when needed */
56923 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56924
56925 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56926 d = PyModule_GetDict(m);
56927
56928 SWIG_InitializeModule(0);
56929 SWIG_InstallConstants(d,swig_const_table);
56930
56931
56932
56933 #ifndef wxPyUSE_EXPORT
56934 // Make our API structure a CObject so other modules can import it
56935 // from this module.
56936 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56937 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56938 Py_XDECREF(cobj);
56939 #endif
56940
56941 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56942 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56943 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56944 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56945 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56946 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56947 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56948 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56949 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56950 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56951 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56952 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56953 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56954 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56955 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56956 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56957 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56958 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56959 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56960 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56961 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56962 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56963 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56964 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56965 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56966 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56967 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56968 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56969 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56970 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56971 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56972 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56973 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56974 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56975 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56976 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56977 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56978 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56979 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56980 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56981 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56982 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56983 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56984 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56985 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56986 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56987 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56988 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56989 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56990 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56991 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56992 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56993 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56994 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56995 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56996 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56997 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56998 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56999 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57000 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57001 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57002 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57003 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57004 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57005 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57006 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57007 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57008 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57009 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57010 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57011 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57012 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57013 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57014 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57015 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57016 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57017 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57018 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57019 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57020 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57021 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57022 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57023 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57024 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57025 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57026 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57027 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57028 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57029 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57030 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57031 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57032 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57033 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57034 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57035 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57036 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57037 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57038 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57039 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57040 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57041 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57042 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57043 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57044 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57045 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57046 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57047 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57048 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57049 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57050 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57051 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57052 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57053 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57054 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57055 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57056 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57057 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57058 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57059 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57060 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57061 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57062 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57063 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57064 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57065 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57066 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57067 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57068 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57069 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57070 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57071 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57072 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57073 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57074 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57075 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57076 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57077 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57078 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57079 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57080 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57081 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57082 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57083 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57084 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57085 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57086 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57087 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57088 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57089 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57090 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57091 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57092 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57093 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57094 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57095 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57096 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57097 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57098 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57099 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57100 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57101 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57102 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57103 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57104 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57105 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57106 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57107 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57108 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57109 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57110 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57111 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57112 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57113 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57114 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57115 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57116 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57117 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57118 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57119 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57120 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57121 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57122 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57123 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57124 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57125 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57126 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57127 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57128 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57129 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57130 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57131 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57132 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57133 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57134 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57135 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57136 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57137 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57138 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57139 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57140 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57141 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57142 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57143 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57144 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57145 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57146 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57147 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57148 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57149 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57150 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57151 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57152 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57153 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57154 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57155 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57156 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57157 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57158 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57159 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57160 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57161 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57162 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57163 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57164 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57165 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57166 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57167 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57168 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57169 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57170 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57171 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57172 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57173 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57174 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57175 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57176 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57177 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57178 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57179 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57180 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57181 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57182 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57183 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57184 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57185 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57186 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57187 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57188 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57189 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57190 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57191 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57192 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57193 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57194 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57195 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57196 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57197 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57198 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57199 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57200 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57201 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57202 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57203 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57204 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57205 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57206 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57207 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57208 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57209 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57210 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57211 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57212 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57213 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57214 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57215 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57216 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57217 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57218 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57219 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57220 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57221 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57222 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57223 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57224 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57225 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57226 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57227 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57228 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57229 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57230 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57231 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57232 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57233 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57234 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57235 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57236 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57237 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57238 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57239 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57240 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57241 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57242 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57243 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57244 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57245 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57246 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57247 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57248 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57249 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57250 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57251 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57252 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57253 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57254 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57255 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57256 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57257 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57258 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57259 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57260 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57261 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57262 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57263 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57264 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57265 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57266 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57267 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57268 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57269 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57270 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57271 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57272 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57273 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57274 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57275 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57276 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57277 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57278 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57279 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57280 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57281 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57282 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57283 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57284 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57285 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57286 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57287 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57288 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57289 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57290 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57291 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57292 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57293 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57294 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57295 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57296 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57297 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57298 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57299 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57300 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57301 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57302 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57303 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57304 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57305 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57306 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57307 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57308 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57309 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57310 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57311 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57312 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57313 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57314 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57315 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57316 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57317 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57318 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57319 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57320 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57321 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57322 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57323 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57324 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57325 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57326 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57327 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57328 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57329 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57330 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57331 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57332 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57333 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57334 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57335 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57336 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57337 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57338 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57339 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57340 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57341 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57342 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57343 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57344 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57345 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57346 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57347 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57348 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57349 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57350 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57351 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57352 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57353 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57354 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57355 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57356 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57357 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57358 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57359 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57360 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57361 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57362 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57363 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57364 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57365 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57366 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57367 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57368 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57369 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57370 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57371 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57372 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57373 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57374 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57375 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57376 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57377 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57378 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57379 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57380 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57381 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57382 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57383 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57384 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57385 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57386 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57387 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57388 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57389 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57390 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57391 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57392 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57393 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57394 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57395 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57396 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57397 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57398 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57399 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57400 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57401 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57402 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57403 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57404 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57405 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57406 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57407 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57408 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57409 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57410 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57411 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57412 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57413 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57414 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57415 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57416 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57417 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57418 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57419 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57420 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57421 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57422 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57423 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57424 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57425 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57426 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57427 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57428 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57429 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57430 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57431 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57432 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57433 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57434 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57435 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57436 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57437 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57438 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57439 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57440 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57441 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57442 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57443 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57444 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57445 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57446 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57447 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57448 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57449 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57450 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57451 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57452 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57453 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57454 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57455 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57456 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57457 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57458 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57459 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57460 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57461 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57462 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57463 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57464 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57465 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57466 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57467 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57468 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57469 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57470 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57471 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57472 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57473 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57474 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57475 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57476 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57477 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57478 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57479 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57480 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57481 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57482 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57483 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57484 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57485 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57486 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57487 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57488 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57489 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57490 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57491 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57492 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57493 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57494 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57495 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57496 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57497 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57498 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57499 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57500 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57501 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57502 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57503 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57504 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57505 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57506 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57507 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57508 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57509 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57510 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57511 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57512 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57513 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57514 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57515 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57516 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57517 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57518 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57519 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57520 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57521 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57522 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57523 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57524 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57525 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57526 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57527 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57528 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57529 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57530 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57531 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57532 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57533 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57534 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57535 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57536 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57537 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57538 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57539 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57540 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57541 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57542 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57543 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57544 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57545 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57546 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57547 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57548 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57549 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57550 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57551 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57552 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57553 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57554 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57555 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57556 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57557 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57558 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57559 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57560 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57561 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57562 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57563 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57564 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57565 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57566 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57567 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57568 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57569 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57570 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57571 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57572 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57573 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57574 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57575 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57576 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57577 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57578 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57579 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57580 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57581 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57582 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57583 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57584 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57585 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57586 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57587 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57588 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57589 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57590 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57591 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57592 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57593 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57594 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57595 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57596 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57597 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57598 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57599 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57600
57601 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57602
57603
57604 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57605
57606 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57607 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57608 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57609 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57610 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57611 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57612 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57613 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57614 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57615 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57616 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57617 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57618 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57619 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57620 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57621 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57622 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57623 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57624 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57625 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57626 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57627 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57628 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57629 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57630 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57631 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57632 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57633 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57634 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57635 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57636 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57637 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57638 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57639 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57640 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57641 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57642 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57643 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57644 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57645 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57646 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57647 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57648 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57649 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57650 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57651 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57652 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57653 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57654 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57655 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57656 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57657 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57658 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57659 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57660 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57661 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57662 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57663 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57664 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57665 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57666 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57667 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57668 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57669 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57670 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57671 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57672 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57673 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57674 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57675 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57676 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57677 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57678 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57679 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57680 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57681 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57682 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57683 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57684 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57685 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57686 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57687 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57688 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57689 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57690 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57691 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57692 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57693 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57694 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57695 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57696 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57697 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57698 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57699 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57700 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57701 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57702 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57703 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57704 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57705 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57706 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57707 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57708 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57709 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57710 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57711 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57712 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57713 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57714 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57715 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57716 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57717 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57718 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57719 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57720 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57721 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57722 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57723 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57724 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57725 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57726 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57727 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57728 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57729 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57730 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57731 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57732 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57733 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57734 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57735 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57736 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57737 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57738 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57739 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57740 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57741 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57742 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57743 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57744 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57745 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57746 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57747 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57748 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57749 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57750 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57751 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57752 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57753 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57754 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57755 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57756 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57757 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57758 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57759 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57760 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57761 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57762 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57763 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57764 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57765 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57766 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57767 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57768 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57769 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57770 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57771 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57772 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57773 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57774 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57775 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57776 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57777 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57778 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57779 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57780 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57781 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57782 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57783 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57784 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57785 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57786 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57787 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57788 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57789 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57790 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57791 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57792 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57793 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57794 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57795 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57796 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57797 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57798 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57799 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57800 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57801 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57802 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57803 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57804 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57805 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57806 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57807 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57808 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57809 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57810 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57811 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57812 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57813 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57814 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57815 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57816 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57817 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57818
57819 // Initialize threading, some globals and such
57820 __wxPyPreStart(d);
57821
57822
57823 // Although these are defined in __version__ they need to be here too so
57824 // that an assert can be done to ensure that the wxPython and the wxWindows
57825 // versions match.
57826 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57827 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57828 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57829
57830 }
57831
wxWidgets (Impactor)