]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxRect2DDouble --> wxRect2D
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTGAHandler swig_types[124]
2591 #define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592 #define SWIGTYPE_p_wxToolTip swig_types[126]
2593 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594 #define SWIGTYPE_p_wxValidator swig_types[128]
2595 #define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596 #define SWIGTYPE_p_wxWindow swig_types[130]
2597 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600 #define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601 static swig_type_info *swig_types[136];
2602 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2603 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2605
2606 /* -------- TYPES TABLE (END) -------- */
2607
2608 #if (PY_VERSION_HEX <= 0x02000000)
2609 # if !defined(SWIG_PYTHON_CLASSIC)
2610 # error "This python version requires to use swig with the '-classic' option"
2611 # endif
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodern' option"
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodernargs' option"
2618 #endif
2619 #ifndef METH_O
2620 # error "This python version requires to use swig with the '-nofastunpack' option"
2621 #endif
2622
2623 /*-----------------------------------------------
2624 @(target):= _core_.so
2625 ------------------------------------------------*/
2626 #define SWIG_init init_core_
2627
2628 #define SWIG_name "_core_"
2629
2630 #define SWIGVERSION 0x010329
2631
2632
2633 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637 #include <stdexcept>
2638
2639
2640 namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683 }
2684
2685
2686 namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697 }
2698
2699
2700 #include "wx/wxPython/wxPython_int.h"
2701 #include "wx/wxPython/pyclasses.h"
2702 #include "wx/wxPython/twoitem.h"
2703
2704
2705 #ifndef wxPyUSE_EXPORT
2706 // Helper functions for dealing with SWIG objects and such. These are
2707 // located here so they know about the SWIG types and functions declared
2708 // in the wrapper code.
2709
2710 #include <wx/hashmap.h>
2711 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2712
2713
2714 // Maintains a hashmap of className to swig_type_info pointers. Given the
2715 // name of a class either looks up the type info in the cache, or scans the
2716 // SWIG tables for it.
2717 extern PyObject* wxPyPtrTypeMap;
2718 static
2719 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
2743 swigType = SWIG_TypeQuery(name.mb_str());
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752 }
2753
2754
2755 // Check if a class name is a type known to SWIG
2756 bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760 }
2761
2762
2763 // Given a pointer to a C++ object and a class name, construct a Python proxy
2764 // object for it.
2765 PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773 }
2774
2775
2776 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2777 // Ensures that the proxy object is of the specified (or derived) type. If
2778 // not able to perform the conversion then a Python exception is set and the
2779 // error should be handled properly in the caller. Returns True on success.
2780 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787 }
2788
2789
2790
2791 // Make a SWIGified pointer object suitable for a .this attribute
2792 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2798
2799 robj = PySwigObject_New(ptr, swigType, 0);
2800 return robj;
2801 }
2802
2803
2804 // Python's PyInstance_Check does not return True for instances of new-style
2805 // classes. This should get close enough for both new and old classes but I
2806 // should re-evaluate the need for doing instance checks...
2807 bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809 }
2810
2811
2812 // This one checks if the object is an instance of a SWIG proxy class (it has
2813 // a .this attribute, and the .this attribute is a PySwigObject.)
2814 bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828 }
2829
2830
2831 // Export a C API in a struct. Other modules will be able to load this from
2832 // the wx._core_ module and will then have safe access to these functions,
2833 // even if they are located in another shared library.
2834 static wxPyCoreAPI API = {
2835
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
2890 wxPyCBInputStream_copy,
2891
2892 wxPyInstance_Check,
2893 wxPySwigInstance_Check,
2894
2895 wxPyCheckForApp,
2896
2897 wxArrayDouble2PyList_helper,
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
2901 };
2902
2903 #endif
2904
2905
2906 #if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908 #endif
2909
2910
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_int (int value)
2916 {
2917 return SWIG_From_long (value);
2918 }
2919
2920 static const wxString wxPyEmptyString(wxEmptyString);
2921 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2922 return self->GetClassInfo()->GetClassName();
2923 }
2924 SWIGINTERN void wxObject_Destroy(wxObject *self){
2925 delete self;
2926 }
2927
2928 #ifndef __WXMAC__
2929 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930 #endif
2931
2932
2933 #include <limits.h>
2934 #ifndef LLONG_MIN
2935 # define LLONG_MIN LONG_LONG_MIN
2936 #endif
2937 #ifndef LLONG_MAX
2938 # define LLONG_MAX LONG_LONG_MAX
2939 #endif
2940 #ifndef ULLONG_MAX
2941 # define ULLONG_MAX ULONG_LONG_MAX
2942 #endif
2943
2944
2945 SWIGINTERN int
2946 SWIG_AsVal_long (PyObject* obj, long* val)
2947 {
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
2950 return SWIG_OK;
2951 }
2952 return SWIG_TypeError;
2953 }
2954
2955
2956 SWIGINTERN int
2957 SWIG_AsVal_int (PyObject * obj, int *val)
2958 {
2959 long v;
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = static_cast< int >(v);
2966 }
2967 }
2968 return res;
2969 }
2970
2971 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
2989
2990 #include <float.h>
2991
2992
2993 SWIGINTERN int
2994 SWIG_AsVal_double (PyObject *obj, double* val)
2995 {
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
2998 return SWIG_OK;
2999 }
3000 return SWIG_TypeError;
3001 }
3002
3003
3004 SWIGINTERN int
3005 SWIG_AsVal_float (PyObject * obj, float *val)
3006 {
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017 }
3018
3019 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3024 //wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027
3028 #define SWIG_From_double PyFloat_FromDouble
3029
3030 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
3048 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3049 self->x = x;
3050 self->y = y;
3051 }
3052 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3057 //PyEndBlockThreads(blocked);
3058 return tup;
3059 }
3060 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
3078 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3079 self->x = x;
3080 self->y = y;
3081 }
3082 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 //wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
3108 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
3114 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3121 //wxPyEndBlockThreads(blocked);
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 wxRect* newRect = new wxRect(dest);
3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3138 //wxPyEndBlockThreads(blocked);
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
3145 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
3163 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
3167 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
3207 return tup;
3208 }
3209
3210 #include "wx/wxPython/pyistream.h"
3211
3212 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
3220 SWIGINTERN swig_type_info*
3221 SWIG_pchar_descriptor()
3222 {
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
3230 }
3231
3232
3233 SWIGINTERNINLINE PyObject *
3234 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3235 {
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
3247 }
3248
3249
3250 SWIGINTERNINLINE PyObject *
3251 SWIG_From_char (char c)
3252 {
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254 }
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_unsigned_SS_long (unsigned long value)
3259 {
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262 }
3263
3264
3265 SWIGINTERNINLINE PyObject *
3266 SWIG_From_size_t (size_t value)
3267 {
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269 }
3270
3271
3272 SWIGINTERN int
3273 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274 {
3275 if (PyString_Check(obj)) {
3276 char *cstr; Py_ssize_t len;
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291 #else
3292 if (*alloc == SWIG_NEWOBJ)
3293 #endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
3301 }
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
3317 }
3318 }
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3326 {
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3331 if (csize <= size) {
3332 if (val) {
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3335 }
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
3341 }
3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3343 }
3344 return SWIG_TypeError;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_char (PyObject * obj, char *val)
3350 {
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
3362 }
3363 return res;
3364 }
3365
3366 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378 #include "wx/wxPython/pyistream.h"
3379
3380
3381 class wxPyFileSystemHandler : public wxFileSystemHandler
3382 {
3383 public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412 };
3413
3414
3415 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_bool (PyObject *obj, bool *val)
3423 {
3424 if (obj == Py_True) {
3425 if (val) *val = true;
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
3428 if (val) *val = false;
3429 return SWIG_OK;
3430 } else {
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
3435 }
3436 }
3437
3438 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
3469 }
3470
3471
3472 #include "wx/wxPython/pyistream.h"
3473
3474
3475 SWIGINTERN int
3476 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3477 {
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3480 return SWIG_TypeError;
3481 }
3482 else if (val)
3483 *val = (unsigned long)v;
3484 return SWIG_OK;
3485 }
3486
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490 {
3491 unsigned long v;
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
3496 } else {
3497 if (val) *val = static_cast< unsigned char >(v);
3498 }
3499 }
3500 return res;
3501 }
3502
3503
3504 SWIGINTERNINLINE PyObject *
3505 SWIG_From_unsigned_SS_char (unsigned char value)
3506 {
3507 return SWIG_From_unsigned_SS_long (value);
3508 }
3509
3510 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
3514 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
3519 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
3526
3527 // Pull the nested class out to the top level for SWIG's sake
3528 #define wxImage_RGBValue wxImage::RGBValue
3529 #define wxImage_HSVValue wxImage::HSVValue
3530
3531 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
3536 }
3537 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3538 return new wxImage(bitmap.ConvertToImage());
3539 }
3540 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
3554 }
3555 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
3572
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
3582 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
3586 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3587 buffer data = self->GetData();
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
3593 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3608 buffer data = self->GetData();
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
3618 }
3619 self->SetData(data, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3622 buffer data = self->GetAlpha();
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
3632 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
3636 }
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
3645 }
3646 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3647 buffer data = self->GetAlpha();
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
3653 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
3657 }
3658 self->SetAlpha(alpha, true);
3659 }
3660 SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3665 wxBitmap bitmap(*self, depth);
3666 return bitmap;
3667 }
3668 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3707
3708 #include <wx/imagtga.h>
3709
3710
3711 #include <wx/quantize.h>
3712
3713 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
3720 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
3736 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
3741 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3742 if (_self && _self != Py_None) {
3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
3752
3753 #if ! wxUSE_HOTKEY
3754 #define wxEVT_HOTKEY -9999
3755 #endif
3756
3757 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3772 #if wxUSE_UNICODE
3773 return self->GetUnicodeKey();
3774 #else
3775 return 0;
3776 #endif
3777 }
3778 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_From_unsigned_SS_int (unsigned int value)
3786 {
3787 return SWIG_From_unsigned_SS_long (value);
3788 }
3789
3790
3791 SWIGINTERN int
3792 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793 {
3794 unsigned long v;
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
3801 }
3802 }
3803 return res;
3804 }
3805
3806 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3807 self->m_size = size;
3808 }
3809 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3817 wxPyEndBlockThreads(blocked);
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return list;
3826 }
3827
3828
3829 SWIGINTERN wxPyApp *new_wxPyApp(){
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
3833 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3834 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3835 return wxPyTestDisplayAvailable();
3836 }
3837
3838 void wxApp_CleanUp() {
3839 __wxPyCleanup();
3840 }
3841
3842
3843 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3844
3845
3846
3847
3848
3849 SWIGINTERNINLINE PyObject *
3850 SWIG_FromCharPtr(const char *cptr)
3851 {
3852 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3853 }
3854
3855
3856 #if 0 // #ifdef __WXMAC__
3857
3858 // A dummy class that raises an exception if used...
3859 class wxEventLoop
3860 {
3861 public:
3862 wxEventLoop() { wxPyRaiseNotImplemented(); }
3863 int Run() { return 0; }
3864 void Exit(int rc = 0) {}
3865 bool Pending() const { return false; }
3866 bool Dispatch() { return false; }
3867 bool IsRunning() const { return false; }
3868 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3869 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3870 };
3871
3872 #else
3873
3874 #include <wx/evtloop.h>
3875
3876 #endif
3877
3878
3879
3880 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3881 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3882 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3883 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3884 wxWindowList& list = self->GetChildren();
3885 return wxPy_ConvertList(&list);
3886 }
3887 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3888 #if wxUSE_HOTKEY
3889 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3890 #else
3891 return false;
3892 #endif
3893 }
3894 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3895
3896
3897
3898 return false;
3899
3900 }
3901 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3902 return wxPyGetWinHandle(self);
3903 }
3904 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3905 self->AssociateHandle((WXWidget)handle);
3906 }
3907 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3908
3909 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3910 return wxWindow::FindWindowById(id, parent);
3911 }
3912
3913 wxWindow* wxFindWindowByName( const wxString& name,
3914 const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowByName(name, parent);
3916 }
3917
3918 wxWindow* wxFindWindowByLabel( const wxString& label,
3919 const wxWindow *parent = NULL ) {
3920 return wxWindow::FindWindowByLabel(label, parent);
3921 }
3922
3923
3924 #ifdef __WXMSW__
3925 #include <wx/msw/private.h> // to get wxGetWindowId
3926 #endif
3927
3928
3929 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3930 #ifdef __WXMSW__
3931 WXHWND hWnd = (WXHWND)_hWnd;
3932 long id = wxGetWindowId(hWnd);
3933 wxWindow* win = new wxWindow;
3934 if (parent)
3935 parent->AddChild(win);
3936 win->SetEventHandler(win);
3937 win->SetHWND(hWnd);
3938 win->SetId(id);
3939 win->SubclassWin(hWnd);
3940 win->AdoptAttributesFromHWND();
3941 win->SetupColours();
3942 return win;
3943 #else
3944 wxPyRaiseNotImplemented();
3945 return NULL;
3946 #endif
3947 }
3948
3949
3950 PyObject* GetTopLevelWindows() {
3951 return wxPy_ConvertList(&wxTopLevelWindows);
3952 }
3953
3954
3955 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3956 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3957 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3958
3959 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3960
3961
3962 SWIGINTERNINLINE int
3963 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3964 {
3965 unsigned long v;
3966 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3967 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3968 return res;
3969 }
3970
3971 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3972 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3973 wxMenuItemList& list = self->GetMenuItems();
3974 return wxPy_ConvertList(&list);
3975 }
3976 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3977 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3978 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3979 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3980 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3981 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3982 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3983 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3984 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3985 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3986 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3987 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3988 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3989 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3990 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3991 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3992 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3993 static const wxString wxPyControlNameStr(wxControlNameStr);
3994 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3995 if (clientData) {
3996 wxPyClientData* data = new wxPyClientData(clientData);
3997 return self->Append(item, data);
3998 } else
3999 return self->Append(item);
4000 }
4001 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4002 if (clientData) {
4003 wxPyClientData* data = new wxPyClientData(clientData);
4004 return self->Insert(item, pos, data);
4005 } else
4006 return self->Insert(item, pos);
4007 }
4008 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4009 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4010 if (data) {
4011 Py_INCREF(data->m_obj);
4012 return data->m_obj;
4013 } else {
4014 Py_INCREF(Py_None);
4015 return Py_None;
4016 }
4017 }
4018 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4019 wxPyClientData* data = new wxPyClientData(clientData);
4020 self->SetClientObject(n, data);
4021 }
4022
4023
4024 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 return new wxSizerItem(window, proportion, flag, border, data);
4032 }
4033 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4034 wxPyUserData* data = NULL;
4035 if ( userData ) {
4036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4037 data = new wxPyUserData(userData);
4038 wxPyEndBlockThreads(blocked);
4039 }
4040 return new wxSizerItem(width, height, proportion, flag, border, data);
4041 }
4042 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4043 wxPyUserData* data = NULL;
4044 if ( userData ) {
4045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4046 data = new wxPyUserData(userData);
4047 wxPyEndBlockThreads(blocked);
4048 }
4049 return new wxSizerItem(sizer, proportion, flag, border, data);
4050 }
4051
4052 SWIGINTERNINLINE PyObject *
4053 SWIG_From_float (float value)
4054 {
4055 return SWIG_From_double (value);
4056 }
4057
4058 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4059 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4060 if (data) {
4061 Py_INCREF(data->m_obj);
4062 return data->m_obj;
4063 } else {
4064 Py_INCREF(Py_None);
4065 return Py_None;
4066 }
4067 }
4068 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4069 wxPyUserData* data = NULL;
4070 if ( userData ) {
4071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4072 data = new wxPyUserData(userData);
4073 wxPyEndBlockThreads(blocked);
4074 }
4075 self->SetUserData(data);
4076 }
4077
4078 // Figure out the type of the sizer item
4079
4080 struct wxPySizerItemInfo {
4081 wxPySizerItemInfo()
4082 : window(NULL), sizer(NULL), gotSize(false),
4083 size(wxDefaultSize), gotPos(false), pos(-1)
4084 {}
4085
4086 wxWindow* window;
4087 wxSizer* sizer;
4088 bool gotSize;
4089 wxSize size;
4090 bool gotPos;
4091 int pos;
4092 };
4093
4094 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4095
4096 wxPySizerItemInfo info;
4097 wxSize size;
4098 wxSize* sizePtr = &size;
4099
4100 // Find out what the type of the item is
4101 // try wxWindow
4102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4103 PyErr_Clear();
4104 info.window = NULL;
4105
4106 // try wxSizer
4107 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4108 PyErr_Clear();
4109 info.sizer = NULL;
4110
4111 // try wxSize or (w,h)
4112 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4113 info.size = *sizePtr;
4114 info.gotSize = true;
4115 }
4116
4117 // or a single int
4118 if (checkIdx && PyInt_Check(item)) {
4119 info.pos = PyInt_AsLong(item);
4120 info.gotPos = true;
4121 }
4122 }
4123 }
4124
4125 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4126 // no expected type, figure out what kind of error message to generate
4127 if ( !checkSize && !checkIdx )
4128 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4129 else if ( checkSize && !checkIdx )
4130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4131 else if ( !checkSize && checkIdx)
4132 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4133 else
4134 // can this one happen?
4135 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4136 }
4137
4138 return info;
4139 }
4140
4141 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4142 if (!self->GetClientObject())
4143 self->SetClientObject(new wxPyOORClientData(_self));
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Add method if a valid item type was found
4157 if ( info.window )
4158 return self->Add(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Add(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4168
4169 wxPyUserData* data = NULL;
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4172 if ( userData && (info.window || info.sizer || info.gotSize) )
4173 data = new wxPyUserData(userData);
4174 if ( info.sizer )
4175 PyObject_SetAttrString(item,"thisown",Py_False);
4176 wxPyEndBlockThreads(blocked);
4177
4178 // Now call the real Insert method if a valid item type was found
4179 if ( info.window )
4180 return self->Insert(before, info.window, proportion, flag, border, data);
4181 else if ( info.sizer )
4182 return self->Insert(before, info.sizer, proportion, flag, border, data);
4183 else if (info.gotSize)
4184 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4185 proportion, flag, border, data);
4186 else
4187 return NULL;
4188 }
4189 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4190
4191 wxPyUserData* data = NULL;
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4194 if ( userData && (info.window || info.sizer || info.gotSize) )
4195 data = new wxPyUserData(userData);
4196 if ( info.sizer )
4197 PyObject_SetAttrString(item,"thisown",Py_False);
4198 wxPyEndBlockThreads(blocked);
4199
4200 // Now call the real Prepend method if a valid item type was found
4201 if ( info.window )
4202 return self->Prepend(info.window, proportion, flag, border, data);
4203 else if ( info.sizer )
4204 return self->Prepend(info.sizer, proportion, flag, border, data);
4205 else if (info.gotSize)
4206 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4207 proportion, flag, border, data);
4208 else
4209 return NULL;
4210 }
4211 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4214 wxPyEndBlockThreads(blocked);
4215 if ( info.window )
4216 return self->Remove(info.window);
4217 else if ( info.sizer )
4218 return self->Remove(info.sizer);
4219 else if ( info.gotPos )
4220 return self->Remove(info.pos);
4221 else
4222 return false;
4223 }
4224 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4225 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4226 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4227 wxPyEndBlockThreads(blocked);
4228 if ( info.window )
4229 return self->Detach(info.window);
4230 else if ( info.sizer )
4231 return self->Detach(info.sizer);
4232 else if ( info.gotPos )
4233 return self->Detach(info.pos);
4234 else
4235 return false;
4236 }
4237 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4239 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4240 wxPyEndBlockThreads(blocked);
4241 if ( info.window )
4242 return self->GetItem(info.window);
4243 else if ( info.sizer )
4244 return self->GetItem(info.sizer);
4245 else if ( info.gotPos )
4246 return self->GetItem(info.pos);
4247 else
4248 return NULL;
4249 }
4250 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4252 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4253 wxPyEndBlockThreads(blocked);
4254 if ( info.window )
4255 self->SetItemMinSize(info.window, size);
4256 else if ( info.sizer )
4257 self->SetItemMinSize(info.sizer, size);
4258 else if ( info.gotPos )
4259 self->SetItemMinSize(info.pos, size);
4260 }
4261 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4262 wxSizerItemList& list = self->GetChildren();
4263 return wxPy_ConvertList(&list);
4264 }
4265 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4268 wxPyEndBlockThreads(blocked);
4269 if ( info.window )
4270 return self->Show(info.window, show, recursive);
4271 else if ( info.sizer )
4272 return self->Show(info.sizer, show, recursive);
4273 else if ( info.gotPos )
4274 return self->Show(info.pos, show);
4275 else
4276 return false;
4277 }
4278 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4281 wxPyEndBlockThreads(blocked);
4282 if ( info.window )
4283 return self->IsShown(info.window);
4284 else if ( info.sizer )
4285 return self->IsShown(info.sizer);
4286 else if ( info.gotPos )
4287 return self->IsShown(info.pos);
4288 else
4289 return false;
4290 }
4291
4292 // See pyclasses.h
4293 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4294 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4295 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4296
4297
4298
4299
4300 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4301 {
4302 if (source == Py_None) {
4303 **obj = wxGBPosition(-1,-1);
4304 return true;
4305 }
4306 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4307 }
4308
4309 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4310 {
4311 if (source == Py_None) {
4312 **obj = wxGBSpan(-1,-1);
4313 return true;
4314 }
4315 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4316 }
4317
4318
4319 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4320 wxGBPosition temp, *obj = &temp;
4321 if ( other == Py_None ) return false;
4322 if ( ! wxGBPosition_helper(other, &obj) ) {
4323 PyErr_Clear();
4324 return false;
4325 }
4326 return self->operator==(*obj);
4327 }
4328 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4329 wxGBPosition temp, *obj = &temp;
4330 if ( other == Py_None ) return true;
4331 if ( ! wxGBPosition_helper(other, &obj)) {
4332 PyErr_Clear();
4333 return true;
4334 }
4335 return self->operator!=(*obj);
4336 }
4337 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4338 self->SetRow(row);
4339 self->SetCol(col);
4340 }
4341 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4343 PyObject* tup = PyTuple_New(2);
4344 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4345 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4346 wxPyEndBlockThreads(blocked);
4347 return tup;
4348 }
4349 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4350 wxGBSpan temp, *obj = &temp;
4351 if ( other == Py_None ) return false;
4352 if ( ! wxGBSpan_helper(other, &obj) ) {
4353 PyErr_Clear();
4354 return false;
4355 }
4356 return self->operator==(*obj);
4357 }
4358 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4359 wxGBSpan temp, *obj = &temp;
4360 if ( other == Py_None ) return true;
4361 if ( ! wxGBSpan_helper(other, &obj)) {
4362 PyErr_Clear();
4363 return true;
4364 }
4365 return self->operator!=(*obj);
4366 }
4367 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4368 self->SetRowspan(rowspan);
4369 self->SetColspan(colspan);
4370 }
4371 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4373 PyObject* tup = PyTuple_New(2);
4374 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4375 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4376 wxPyEndBlockThreads(blocked);
4377 return tup;
4378 }
4379 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4380 wxPyUserData* data = NULL;
4381 if ( userData ) {
4382 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4383 data = new wxPyUserData(userData);
4384 wxPyEndBlockThreads(blocked);
4385 }
4386 return new wxGBSizerItem(window, pos, span, flag, border, data);
4387 }
4388 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4389 wxPyUserData* data = NULL;
4390 if ( userData ) {
4391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4392 data = new wxPyUserData(userData);
4393 wxPyEndBlockThreads(blocked);
4394 }
4395 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4396 }
4397 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4398 wxPyUserData* data = NULL;
4399 if ( userData ) {
4400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4401 data = new wxPyUserData(userData);
4402 wxPyEndBlockThreads(blocked);
4403 }
4404 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4405 }
4406 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4407 int row, col;
4408 self->GetEndPos(row, col);
4409 return wxGBPosition(row, col);
4410 }
4411 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4412
4413 wxPyUserData* data = NULL;
4414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4415 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4416 if ( userData && (info.window || info.sizer || info.gotSize) )
4417 data = new wxPyUserData(userData);
4418 if ( info.sizer )
4419 PyObject_SetAttrString(item,"thisown",Py_False);
4420 wxPyEndBlockThreads(blocked);
4421
4422 // Now call the real Add method if a valid item type was found
4423 if ( info.window )
4424 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4425 else if ( info.sizer )
4426 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4427 else if (info.gotSize)
4428 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4429 pos, span, flag, border, data);
4430 return NULL;
4431 }
4432
4433
4434 #ifdef __cplusplus
4435 extern "C" {
4436 #endif
4437 SWIGINTERN int EmptyString_set(PyObject *) {
4438 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4439 return 1;
4440 }
4441
4442
4443 SWIGINTERN PyObject *EmptyString_get(void) {
4444 PyObject *pyobj = 0;
4445
4446 {
4447 #if wxUSE_UNICODE
4448 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4449 #else
4450 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4451 #endif
4452 }
4453 return pyobj;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *resultobj = 0;
4459 wxObject *arg1 = (wxObject *) 0 ;
4460 wxString result;
4461 void *argp1 = 0 ;
4462 int res1 = 0 ;
4463 PyObject *swig_obj[1] ;
4464
4465 if (!args) SWIG_fail;
4466 swig_obj[0] = args;
4467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4468 if (!SWIG_IsOK(res1)) {
4469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4470 }
4471 arg1 = reinterpret_cast< wxObject * >(argp1);
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = wxObject_GetClassName(arg1);
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 {
4479 #if wxUSE_UNICODE
4480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4481 #else
4482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4483 #endif
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxObject *arg1 = (wxObject *) 0 ;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4503 }
4504 arg1 = reinterpret_cast< wxObject * >(argp1);
4505 {
4506 PyThreadState* __tstate = wxPyBeginAllowThreads();
4507 wxObject_Destroy(arg1);
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 resultobj = SWIG_Py_Void();
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4519 PyObject *resultobj = 0;
4520 wxObject *arg1 = (wxObject *) 0 ;
4521 wxObject *arg2 = 0 ;
4522 bool result;
4523 void *argp1 = 0 ;
4524 int res1 = 0 ;
4525 void *argp2 = 0 ;
4526 int res2 = 0 ;
4527 PyObject * obj0 = 0 ;
4528 PyObject * obj1 = 0 ;
4529 char * kwnames[] = {
4530 (char *) "self",(char *) "p", NULL
4531 };
4532
4533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4535 if (!SWIG_IsOK(res1)) {
4536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4537 }
4538 arg1 = reinterpret_cast< wxObject * >(argp1);
4539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4540 if (!SWIG_IsOK(res2)) {
4541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4542 }
4543 if (!argp2) {
4544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4545 }
4546 arg2 = reinterpret_cast< wxObject * >(argp2);
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4550 wxPyEndAllowThreads(__tstate);
4551 if (PyErr_Occurred()) SWIG_fail;
4552 }
4553 {
4554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4555 }
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4563 PyObject *obj;
4564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4565 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4566 return SWIG_Py_Void();
4567 }
4568
4569 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4570 PyObject *resultobj = 0;
4571 wxSize *arg1 = (wxSize *) 0 ;
4572 int arg2 ;
4573 void *argp1 = 0 ;
4574 int res1 = 0 ;
4575 int val2 ;
4576 int ecode2 = 0 ;
4577 PyObject *swig_obj[2] ;
4578
4579 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4581 if (!SWIG_IsOK(res1)) {
4582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4583 }
4584 arg1 = reinterpret_cast< wxSize * >(argp1);
4585 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4586 if (!SWIG_IsOK(ecode2)) {
4587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4588 }
4589 arg2 = static_cast< int >(val2);
4590 if (arg1) (arg1)->x = arg2;
4591
4592 resultobj = SWIG_Py_Void();
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600 PyObject *resultobj = 0;
4601 wxSize *arg1 = (wxSize *) 0 ;
4602 int result;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 PyObject *swig_obj[1] ;
4606
4607 if (!args) SWIG_fail;
4608 swig_obj[0] = args;
4609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4612 }
4613 arg1 = reinterpret_cast< wxSize * >(argp1);
4614 result = (int) ((arg1)->x);
4615 resultobj = SWIG_From_int(static_cast< int >(result));
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4623 PyObject *resultobj = 0;
4624 wxSize *arg1 = (wxSize *) 0 ;
4625 int arg2 ;
4626 void *argp1 = 0 ;
4627 int res1 = 0 ;
4628 int val2 ;
4629 int ecode2 = 0 ;
4630 PyObject *swig_obj[2] ;
4631
4632 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4634 if (!SWIG_IsOK(res1)) {
4635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4636 }
4637 arg1 = reinterpret_cast< wxSize * >(argp1);
4638 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4639 if (!SWIG_IsOK(ecode2)) {
4640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4641 }
4642 arg2 = static_cast< int >(val2);
4643 if (arg1) (arg1)->y = arg2;
4644
4645 resultobj = SWIG_Py_Void();
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 int result;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 PyObject *swig_obj[1] ;
4659
4660 if (!args) SWIG_fail;
4661 swig_obj[0] = args;
4662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4663 if (!SWIG_IsOK(res1)) {
4664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4665 }
4666 arg1 = reinterpret_cast< wxSize * >(argp1);
4667 result = (int) ((arg1)->y);
4668 resultobj = SWIG_From_int(static_cast< int >(result));
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 int arg1 = (int) 0 ;
4678 int arg2 = (int) 0 ;
4679 wxSize *result = 0 ;
4680 int val1 ;
4681 int ecode1 = 0 ;
4682 int val2 ;
4683 int ecode2 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "w",(char *) "h", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4691 if (obj0) {
4692 ecode1 = SWIG_AsVal_int(obj0, &val1);
4693 if (!SWIG_IsOK(ecode1)) {
4694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4695 }
4696 arg1 = static_cast< int >(val1);
4697 }
4698 if (obj1) {
4699 ecode2 = SWIG_AsVal_int(obj1, &val2);
4700 if (!SWIG_IsOK(ecode2)) {
4701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4702 }
4703 arg2 = static_cast< int >(val2);
4704 }
4705 {
4706 result = (wxSize *)new wxSize(arg1,arg2);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4717 PyObject *resultobj = 0;
4718 wxSize *arg1 = (wxSize *) 0 ;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 PyObject *swig_obj[1] ;
4722
4723 if (!args) SWIG_fail;
4724 swig_obj[0] = args;
4725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 {
4731 delete arg1;
4732
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 resultobj = SWIG_Py_Void();
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj = 0;
4744 wxSize *arg1 = (wxSize *) 0 ;
4745 PyObject *arg2 = (PyObject *) 0 ;
4746 bool result;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "other", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 arg2 = obj1;
4762 {
4763 result = (bool)wxSize___eq__(arg1,arg2);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 {
4767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4768 }
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj = 0;
4777 wxSize *arg1 = (wxSize *) 0 ;
4778 PyObject *arg2 = (PyObject *) 0 ;
4779 bool result;
4780 void *argp1 = 0 ;
4781 int res1 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 char * kwnames[] = {
4785 (char *) "self",(char *) "other", NULL
4786 };
4787
4788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4790 if (!SWIG_IsOK(res1)) {
4791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4792 }
4793 arg1 = reinterpret_cast< wxSize * >(argp1);
4794 arg2 = obj1;
4795 {
4796 result = (bool)wxSize___ne__(arg1,arg2);
4797 if (PyErr_Occurred()) SWIG_fail;
4798 }
4799 {
4800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4801 }
4802 return resultobj;
4803 fail:
4804 return NULL;
4805 }
4806
4807
4808 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4809 PyObject *resultobj = 0;
4810 wxSize *arg1 = (wxSize *) 0 ;
4811 wxSize *arg2 = 0 ;
4812 wxSize result;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 wxSize temp2 ;
4816 PyObject * obj0 = 0 ;
4817 PyObject * obj1 = 0 ;
4818 char * kwnames[] = {
4819 (char *) "self",(char *) "sz", NULL
4820 };
4821
4822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4824 if (!SWIG_IsOK(res1)) {
4825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4826 }
4827 arg1 = reinterpret_cast< wxSize * >(argp1);
4828 {
4829 arg2 = &temp2;
4830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4831 }
4832 {
4833 result = (arg1)->operator +((wxSize const &)*arg2);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4837 return resultobj;
4838 fail:
4839 return NULL;
4840 }
4841
4842
4843 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj = 0;
4845 wxSize *arg1 = (wxSize *) 0 ;
4846 wxSize *arg2 = 0 ;
4847 wxSize result;
4848 void *argp1 = 0 ;
4849 int res1 = 0 ;
4850 wxSize temp2 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "self",(char *) "sz", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4861 }
4862 arg1 = reinterpret_cast< wxSize * >(argp1);
4863 {
4864 arg2 = &temp2;
4865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4866 }
4867 {
4868 result = (arg1)->operator -((wxSize const &)*arg2);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4879 PyObject *resultobj = 0;
4880 wxSize *arg1 = (wxSize *) 0 ;
4881 wxSize *arg2 = 0 ;
4882 void *argp1 = 0 ;
4883 int res1 = 0 ;
4884 wxSize temp2 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "self",(char *) "sz", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4893 if (!SWIG_IsOK(res1)) {
4894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4895 }
4896 arg1 = reinterpret_cast< wxSize * >(argp1);
4897 {
4898 arg2 = &temp2;
4899 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4900 }
4901 {
4902 (arg1)->IncTo((wxSize const &)*arg2);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_Py_Void();
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj = 0;
4914 wxSize *arg1 = (wxSize *) 0 ;
4915 wxSize *arg2 = 0 ;
4916 void *argp1 = 0 ;
4917 int res1 = 0 ;
4918 wxSize temp2 ;
4919 PyObject * obj0 = 0 ;
4920 PyObject * obj1 = 0 ;
4921 char * kwnames[] = {
4922 (char *) "self",(char *) "sz", NULL
4923 };
4924
4925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4927 if (!SWIG_IsOK(res1)) {
4928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4929 }
4930 arg1 = reinterpret_cast< wxSize * >(argp1);
4931 {
4932 arg2 = &temp2;
4933 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4934 }
4935 {
4936 (arg1)->DecTo((wxSize const &)*arg2);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 resultobj = SWIG_Py_Void();
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
4946 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4947 PyObject *resultobj = 0;
4948 wxSize *arg1 = (wxSize *) 0 ;
4949 int arg2 ;
4950 int arg3 ;
4951 void *argp1 = 0 ;
4952 int res1 = 0 ;
4953 int val2 ;
4954 int ecode2 = 0 ;
4955 int val3 ;
4956 int ecode3 = 0 ;
4957 PyObject * obj0 = 0 ;
4958 PyObject * obj1 = 0 ;
4959 PyObject * obj2 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "dx",(char *) "dy", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4968 }
4969 arg1 = reinterpret_cast< wxSize * >(argp1);
4970 ecode2 = SWIG_AsVal_int(obj1, &val2);
4971 if (!SWIG_IsOK(ecode2)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4973 }
4974 arg2 = static_cast< int >(val2);
4975 ecode3 = SWIG_AsVal_int(obj2, &val3);
4976 if (!SWIG_IsOK(ecode3)) {
4977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4978 }
4979 arg3 = static_cast< int >(val3);
4980 {
4981 (arg1)->IncBy(arg2,arg3);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 resultobj = SWIG_Py_Void();
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4992 PyObject *resultobj = 0;
4993 wxSize *arg1 = (wxSize *) 0 ;
4994 int arg2 ;
4995 int arg3 ;
4996 void *argp1 = 0 ;
4997 int res1 = 0 ;
4998 int val2 ;
4999 int ecode2 = 0 ;
5000 int val3 ;
5001 int ecode3 = 0 ;
5002 PyObject * obj0 = 0 ;
5003 PyObject * obj1 = 0 ;
5004 PyObject * obj2 = 0 ;
5005 char * kwnames[] = {
5006 (char *) "self",(char *) "dx",(char *) "dy", NULL
5007 };
5008
5009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 ecode2 = SWIG_AsVal_int(obj1, &val2);
5016 if (!SWIG_IsOK(ecode2)) {
5017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5018 }
5019 arg2 = static_cast< int >(val2);
5020 ecode3 = SWIG_AsVal_int(obj2, &val3);
5021 if (!SWIG_IsOK(ecode3)) {
5022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5023 }
5024 arg3 = static_cast< int >(val3);
5025 {
5026 (arg1)->DecBy(arg2,arg3);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 resultobj = SWIG_Py_Void();
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5037 PyObject *resultobj = 0;
5038 wxSize *arg1 = (wxSize *) 0 ;
5039 float arg2 ;
5040 float arg3 ;
5041 void *argp1 = 0 ;
5042 int res1 = 0 ;
5043 float val2 ;
5044 int ecode2 = 0 ;
5045 float val3 ;
5046 int ecode3 = 0 ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 PyObject * obj2 = 0 ;
5050 char * kwnames[] = {
5051 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5052 };
5053
5054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5056 if (!SWIG_IsOK(res1)) {
5057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5058 }
5059 arg1 = reinterpret_cast< wxSize * >(argp1);
5060 ecode2 = SWIG_AsVal_float(obj1, &val2);
5061 if (!SWIG_IsOK(ecode2)) {
5062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5063 }
5064 arg2 = static_cast< float >(val2);
5065 ecode3 = SWIG_AsVal_float(obj2, &val3);
5066 if (!SWIG_IsOK(ecode3)) {
5067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5068 }
5069 arg3 = static_cast< float >(val3);
5070 {
5071 (arg1)->Scale(arg2,arg3);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 int arg2 ;
5085 int arg3 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 int val2 ;
5089 int ecode2 = 0 ;
5090 int val3 ;
5091 int ecode3 = 0 ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 PyObject * obj2 = 0 ;
5095 char * kwnames[] = {
5096 (char *) "self",(char *) "w",(char *) "h", NULL
5097 };
5098
5099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5101 if (!SWIG_IsOK(res1)) {
5102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5103 }
5104 arg1 = reinterpret_cast< wxSize * >(argp1);
5105 ecode2 = SWIG_AsVal_int(obj1, &val2);
5106 if (!SWIG_IsOK(ecode2)) {
5107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5108 }
5109 arg2 = static_cast< int >(val2);
5110 ecode3 = SWIG_AsVal_int(obj2, &val3);
5111 if (!SWIG_IsOK(ecode3)) {
5112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5113 }
5114 arg3 = static_cast< int >(val3);
5115 {
5116 (arg1)->Set(arg2,arg3);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 resultobj = SWIG_Py_Void();
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 int arg2 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 int val2 ;
5133 int ecode2 = 0 ;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 char * kwnames[] = {
5137 (char *) "self",(char *) "w", NULL
5138 };
5139
5140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5144 }
5145 arg1 = reinterpret_cast< wxSize * >(argp1);
5146 ecode2 = SWIG_AsVal_int(obj1, &val2);
5147 if (!SWIG_IsOK(ecode2)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5149 }
5150 arg2 = static_cast< int >(val2);
5151 {
5152 (arg1)->SetWidth(arg2);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 int arg2 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 int val2 ;
5169 int ecode2 = 0 ;
5170 PyObject * obj0 = 0 ;
5171 PyObject * obj1 = 0 ;
5172 char * kwnames[] = {
5173 (char *) "self",(char *) "h", NULL
5174 };
5175
5176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5180 }
5181 arg1 = reinterpret_cast< wxSize * >(argp1);
5182 ecode2 = SWIG_AsVal_int(obj1, &val2);
5183 if (!SWIG_IsOK(ecode2)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5185 }
5186 arg2 = static_cast< int >(val2);
5187 {
5188 (arg1)->SetHeight(arg2);
5189 if (PyErr_Occurred()) SWIG_fail;
5190 }
5191 resultobj = SWIG_Py_Void();
5192 return resultobj;
5193 fail:
5194 return NULL;
5195 }
5196
5197
5198 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5199 PyObject *resultobj = 0;
5200 wxSize *arg1 = (wxSize *) 0 ;
5201 int result;
5202 void *argp1 = 0 ;
5203 int res1 = 0 ;
5204 PyObject *swig_obj[1] ;
5205
5206 if (!args) SWIG_fail;
5207 swig_obj[0] = args;
5208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5209 if (!SWIG_IsOK(res1)) {
5210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5211 }
5212 arg1 = reinterpret_cast< wxSize * >(argp1);
5213 {
5214 result = (int)((wxSize const *)arg1)->GetWidth();
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 resultobj = SWIG_From_int(static_cast< int >(result));
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5225 PyObject *resultobj = 0;
5226 wxSize *arg1 = (wxSize *) 0 ;
5227 int result;
5228 void *argp1 = 0 ;
5229 int res1 = 0 ;
5230 PyObject *swig_obj[1] ;
5231
5232 if (!args) SWIG_fail;
5233 swig_obj[0] = args;
5234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5235 if (!SWIG_IsOK(res1)) {
5236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5237 }
5238 arg1 = reinterpret_cast< wxSize * >(argp1);
5239 {
5240 result = (int)((wxSize const *)arg1)->GetHeight();
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_From_int(static_cast< int >(result));
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5251 PyObject *resultobj = 0;
5252 wxSize *arg1 = (wxSize *) 0 ;
5253 bool result;
5254 void *argp1 = 0 ;
5255 int res1 = 0 ;
5256 PyObject *swig_obj[1] ;
5257
5258 if (!args) SWIG_fail;
5259 swig_obj[0] = args;
5260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5261 if (!SWIG_IsOK(res1)) {
5262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5263 }
5264 arg1 = reinterpret_cast< wxSize * >(argp1);
5265 {
5266 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 {
5270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5271 }
5272 return resultobj;
5273 fail:
5274 return NULL;
5275 }
5276
5277
5278 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5279 PyObject *resultobj = 0;
5280 wxSize *arg1 = (wxSize *) 0 ;
5281 wxSize *arg2 = 0 ;
5282 void *argp1 = 0 ;
5283 int res1 = 0 ;
5284 wxSize temp2 ;
5285 PyObject * obj0 = 0 ;
5286 PyObject * obj1 = 0 ;
5287 char * kwnames[] = {
5288 (char *) "self",(char *) "size", NULL
5289 };
5290
5291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5295 }
5296 arg1 = reinterpret_cast< wxSize * >(argp1);
5297 {
5298 arg2 = &temp2;
5299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5300 }
5301 {
5302 (arg1)->SetDefaults((wxSize const &)*arg2);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 PyObject *resultobj = 0;
5314 wxSize *arg1 = (wxSize *) 0 ;
5315 PyObject *result = 0 ;
5316 void *argp1 = 0 ;
5317 int res1 = 0 ;
5318 PyObject *swig_obj[1] ;
5319
5320 if (!args) SWIG_fail;
5321 swig_obj[0] = args;
5322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5323 if (!SWIG_IsOK(res1)) {
5324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5325 }
5326 arg1 = reinterpret_cast< wxSize * >(argp1);
5327 {
5328 result = (PyObject *)wxSize_Get(arg1);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 resultobj = result;
5332 return resultobj;
5333 fail:
5334 return NULL;
5335 }
5336
5337
5338 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5339 PyObject *obj;
5340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5341 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5342 return SWIG_Py_Void();
5343 }
5344
5345 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5346 return SWIG_Python_InitShadowInstance(args);
5347 }
5348
5349 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 double arg2 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 double val2 ;
5356 int ecode2 = 0 ;
5357 PyObject *swig_obj[2] ;
5358
5359 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5363 }
5364 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5365 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5366 if (!SWIG_IsOK(ecode2)) {
5367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5368 }
5369 arg2 = static_cast< double >(val2);
5370 if (arg1) (arg1)->x = arg2;
5371
5372 resultobj = SWIG_Py_Void();
5373 return resultobj;
5374 fail:
5375 return NULL;
5376 }
5377
5378
5379 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5380 PyObject *resultobj = 0;
5381 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5382 double result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject *swig_obj[1] ;
5386
5387 if (!args) SWIG_fail;
5388 swig_obj[0] = args;
5389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5392 }
5393 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5394 result = (double) ((arg1)->x);
5395 resultobj = SWIG_From_double(static_cast< double >(result));
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5403 PyObject *resultobj = 0;
5404 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5405 double arg2 ;
5406 void *argp1 = 0 ;
5407 int res1 = 0 ;
5408 double val2 ;
5409 int ecode2 = 0 ;
5410 PyObject *swig_obj[2] ;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5414 if (!SWIG_IsOK(res1)) {
5415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5416 }
5417 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5418 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5419 if (!SWIG_IsOK(ecode2)) {
5420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5421 }
5422 arg2 = static_cast< double >(val2);
5423 if (arg1) (arg1)->y = arg2;
5424
5425 resultobj = SWIG_Py_Void();
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5435 double result;
5436 void *argp1 = 0 ;
5437 int res1 = 0 ;
5438 PyObject *swig_obj[1] ;
5439
5440 if (!args) SWIG_fail;
5441 swig_obj[0] = args;
5442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5443 if (!SWIG_IsOK(res1)) {
5444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5445 }
5446 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5447 result = (double) ((arg1)->y);
5448 resultobj = SWIG_From_double(static_cast< double >(result));
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5456 PyObject *resultobj = 0;
5457 double arg1 = (double) 0.0 ;
5458 double arg2 = (double) 0.0 ;
5459 wxRealPoint *result = 0 ;
5460 double val1 ;
5461 int ecode1 = 0 ;
5462 double val2 ;
5463 int ecode2 = 0 ;
5464 PyObject * obj0 = 0 ;
5465 PyObject * obj1 = 0 ;
5466 char * kwnames[] = {
5467 (char *) "x",(char *) "y", NULL
5468 };
5469
5470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5471 if (obj0) {
5472 ecode1 = SWIG_AsVal_double(obj0, &val1);
5473 if (!SWIG_IsOK(ecode1)) {
5474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5475 }
5476 arg1 = static_cast< double >(val1);
5477 }
5478 if (obj1) {
5479 ecode2 = SWIG_AsVal_double(obj1, &val2);
5480 if (!SWIG_IsOK(ecode2)) {
5481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5482 }
5483 arg2 = static_cast< double >(val2);
5484 }
5485 {
5486 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5499 void *argp1 = 0 ;
5500 int res1 = 0 ;
5501 PyObject *swig_obj[1] ;
5502
5503 if (!args) SWIG_fail;
5504 swig_obj[0] = args;
5505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 {
5511 delete arg1;
5512
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 resultobj = SWIG_Py_Void();
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = 0;
5524 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5525 PyObject *arg2 = (PyObject *) 0 ;
5526 bool result;
5527 void *argp1 = 0 ;
5528 int res1 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "other", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 arg2 = obj1;
5542 {
5543 result = (bool)wxRealPoint___eq__(arg1,arg2);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj = 0;
5557 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5558 PyObject *arg2 = (PyObject *) 0 ;
5559 bool result;
5560 void *argp1 = 0 ;
5561 int res1 = 0 ;
5562 PyObject * obj0 = 0 ;
5563 PyObject * obj1 = 0 ;
5564 char * kwnames[] = {
5565 (char *) "self",(char *) "other", NULL
5566 };
5567
5568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5570 if (!SWIG_IsOK(res1)) {
5571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5572 }
5573 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5574 arg2 = obj1;
5575 {
5576 result = (bool)wxRealPoint___ne__(arg1,arg2);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj = 0;
5590 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5591 wxRealPoint *arg2 = 0 ;
5592 wxRealPoint result;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 wxRealPoint temp2 ;
5596 PyObject * obj0 = 0 ;
5597 PyObject * obj1 = 0 ;
5598 char * kwnames[] = {
5599 (char *) "self",(char *) "pt", NULL
5600 };
5601
5602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5604 if (!SWIG_IsOK(res1)) {
5605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5606 }
5607 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5608 {
5609 arg2 = &temp2;
5610 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5611 }
5612 {
5613 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj = 0;
5625 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5626 wxRealPoint *arg2 = 0 ;
5627 wxRealPoint result;
5628 void *argp1 = 0 ;
5629 int res1 = 0 ;
5630 wxRealPoint temp2 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 char * kwnames[] = {
5634 (char *) "self",(char *) "pt", NULL
5635 };
5636
5637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5639 if (!SWIG_IsOK(res1)) {
5640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5641 }
5642 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5643 {
5644 arg2 = &temp2;
5645 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5646 }
5647 {
5648 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj = 0;
5660 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5661 double arg2 ;
5662 double arg3 ;
5663 void *argp1 = 0 ;
5664 int res1 = 0 ;
5665 double val2 ;
5666 int ecode2 = 0 ;
5667 double val3 ;
5668 int ecode3 = 0 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 PyObject * obj2 = 0 ;
5672 char * kwnames[] = {
5673 (char *) "self",(char *) "x",(char *) "y", NULL
5674 };
5675
5676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5682 ecode2 = SWIG_AsVal_double(obj1, &val2);
5683 if (!SWIG_IsOK(ecode2)) {
5684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5685 }
5686 arg2 = static_cast< double >(val2);
5687 ecode3 = SWIG_AsVal_double(obj2, &val3);
5688 if (!SWIG_IsOK(ecode3)) {
5689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5690 }
5691 arg3 = static_cast< double >(val3);
5692 {
5693 wxRealPoint_Set(arg1,arg2,arg3);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 resultobj = SWIG_Py_Void();
5697 return resultobj;
5698 fail:
5699 return NULL;
5700 }
5701
5702
5703 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5704 PyObject *resultobj = 0;
5705 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5706 PyObject *result = 0 ;
5707 void *argp1 = 0 ;
5708 int res1 = 0 ;
5709 PyObject *swig_obj[1] ;
5710
5711 if (!args) SWIG_fail;
5712 swig_obj[0] = args;
5713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5714 if (!SWIG_IsOK(res1)) {
5715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5716 }
5717 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5718 {
5719 result = (PyObject *)wxRealPoint_Get(arg1);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 resultobj = result;
5723 return resultobj;
5724 fail:
5725 return NULL;
5726 }
5727
5728
5729 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *obj;
5731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5732 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5733 return SWIG_Py_Void();
5734 }
5735
5736 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5737 return SWIG_Python_InitShadowInstance(args);
5738 }
5739
5740 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5741 PyObject *resultobj = 0;
5742 wxPoint *arg1 = (wxPoint *) 0 ;
5743 int arg2 ;
5744 void *argp1 = 0 ;
5745 int res1 = 0 ;
5746 int val2 ;
5747 int ecode2 = 0 ;
5748 PyObject *swig_obj[2] ;
5749
5750 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxPoint * >(argp1);
5756 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5757 if (!SWIG_IsOK(ecode2)) {
5758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5759 }
5760 arg2 = static_cast< int >(val2);
5761 if (arg1) (arg1)->x = arg2;
5762
5763 resultobj = SWIG_Py_Void();
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5771 PyObject *resultobj = 0;
5772 wxPoint *arg1 = (wxPoint *) 0 ;
5773 int result;
5774 void *argp1 = 0 ;
5775 int res1 = 0 ;
5776 PyObject *swig_obj[1] ;
5777
5778 if (!args) SWIG_fail;
5779 swig_obj[0] = args;
5780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5781 if (!SWIG_IsOK(res1)) {
5782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5783 }
5784 arg1 = reinterpret_cast< wxPoint * >(argp1);
5785 result = (int) ((arg1)->x);
5786 resultobj = SWIG_From_int(static_cast< int >(result));
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5794 PyObject *resultobj = 0;
5795 wxPoint *arg1 = (wxPoint *) 0 ;
5796 int arg2 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 int val2 ;
5800 int ecode2 = 0 ;
5801 PyObject *swig_obj[2] ;
5802
5803 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5805 if (!SWIG_IsOK(res1)) {
5806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5807 }
5808 arg1 = reinterpret_cast< wxPoint * >(argp1);
5809 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5810 if (!SWIG_IsOK(ecode2)) {
5811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5812 }
5813 arg2 = static_cast< int >(val2);
5814 if (arg1) (arg1)->y = arg2;
5815
5816 resultobj = SWIG_Py_Void();
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5824 PyObject *resultobj = 0;
5825 wxPoint *arg1 = (wxPoint *) 0 ;
5826 int result;
5827 void *argp1 = 0 ;
5828 int res1 = 0 ;
5829 PyObject *swig_obj[1] ;
5830
5831 if (!args) SWIG_fail;
5832 swig_obj[0] = args;
5833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5834 if (!SWIG_IsOK(res1)) {
5835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5836 }
5837 arg1 = reinterpret_cast< wxPoint * >(argp1);
5838 result = (int) ((arg1)->y);
5839 resultobj = SWIG_From_int(static_cast< int >(result));
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 int arg1 = (int) 0 ;
5849 int arg2 = (int) 0 ;
5850 wxPoint *result = 0 ;
5851 int val1 ;
5852 int ecode1 = 0 ;
5853 int val2 ;
5854 int ecode2 = 0 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "x",(char *) "y", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5862 if (obj0) {
5863 ecode1 = SWIG_AsVal_int(obj0, &val1);
5864 if (!SWIG_IsOK(ecode1)) {
5865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5866 }
5867 arg1 = static_cast< int >(val1);
5868 }
5869 if (obj1) {
5870 ecode2 = SWIG_AsVal_int(obj1, &val2);
5871 if (!SWIG_IsOK(ecode2)) {
5872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5873 }
5874 arg2 = static_cast< int >(val2);
5875 }
5876 {
5877 result = (wxPoint *)new wxPoint(arg1,arg2);
5878 if (PyErr_Occurred()) SWIG_fail;
5879 }
5880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5881 return resultobj;
5882 fail:
5883 return NULL;
5884 }
5885
5886
5887 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5888 PyObject *resultobj = 0;
5889 wxPoint *arg1 = (wxPoint *) 0 ;
5890 void *argp1 = 0 ;
5891 int res1 = 0 ;
5892 PyObject *swig_obj[1] ;
5893
5894 if (!args) SWIG_fail;
5895 swig_obj[0] = args;
5896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5897 if (!SWIG_IsOK(res1)) {
5898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5899 }
5900 arg1 = reinterpret_cast< wxPoint * >(argp1);
5901 {
5902 delete arg1;
5903
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 resultobj = SWIG_Py_Void();
5907 return resultobj;
5908 fail:
5909 return NULL;
5910 }
5911
5912
5913 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5914 PyObject *resultobj = 0;
5915 wxPoint *arg1 = (wxPoint *) 0 ;
5916 PyObject *arg2 = (PyObject *) 0 ;
5917 bool result;
5918 void *argp1 = 0 ;
5919 int res1 = 0 ;
5920 PyObject * obj0 = 0 ;
5921 PyObject * obj1 = 0 ;
5922 char * kwnames[] = {
5923 (char *) "self",(char *) "other", NULL
5924 };
5925
5926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5928 if (!SWIG_IsOK(res1)) {
5929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5930 }
5931 arg1 = reinterpret_cast< wxPoint * >(argp1);
5932 arg2 = obj1;
5933 {
5934 result = (bool)wxPoint___eq__(arg1,arg2);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5939 }
5940 return resultobj;
5941 fail:
5942 return NULL;
5943 }
5944
5945
5946 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5947 PyObject *resultobj = 0;
5948 wxPoint *arg1 = (wxPoint *) 0 ;
5949 PyObject *arg2 = (PyObject *) 0 ;
5950 bool result;
5951 void *argp1 = 0 ;
5952 int res1 = 0 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "other", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 arg2 = obj1;
5966 {
5967 result = (bool)wxPoint___ne__(arg1,arg2);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 {
5971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5972 }
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj = 0;
5981 wxPoint *arg1 = (wxPoint *) 0 ;
5982 wxPoint *arg2 = 0 ;
5983 wxPoint result;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 wxPoint temp2 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 char * kwnames[] = {
5990 (char *) "self",(char *) "pt", NULL
5991 };
5992
5993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5995 if (!SWIG_IsOK(res1)) {
5996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5997 }
5998 arg1 = reinterpret_cast< wxPoint * >(argp1);
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 result = (arg1)->operator +((wxPoint const &)*arg2);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6008 return resultobj;
6009 fail:
6010 return NULL;
6011 }
6012
6013
6014 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj = 0;
6016 wxPoint *arg1 = (wxPoint *) 0 ;
6017 wxPoint *arg2 = 0 ;
6018 wxPoint result;
6019 void *argp1 = 0 ;
6020 int res1 = 0 ;
6021 wxPoint temp2 ;
6022 PyObject * obj0 = 0 ;
6023 PyObject * obj1 = 0 ;
6024 char * kwnames[] = {
6025 (char *) "self",(char *) "pt", NULL
6026 };
6027
6028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6030 if (!SWIG_IsOK(res1)) {
6031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6032 }
6033 arg1 = reinterpret_cast< wxPoint * >(argp1);
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 result = (arg1)->operator -((wxPoint const &)*arg2);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj = 0;
6051 wxPoint *arg1 = (wxPoint *) 0 ;
6052 wxPoint *arg2 = 0 ;
6053 wxPoint *result = 0 ;
6054 void *argp1 = 0 ;
6055 int res1 = 0 ;
6056 wxPoint temp2 ;
6057 PyObject * obj0 = 0 ;
6058 PyObject * obj1 = 0 ;
6059 char * kwnames[] = {
6060 (char *) "self",(char *) "pt", NULL
6061 };
6062
6063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6065 if (!SWIG_IsOK(res1)) {
6066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6067 }
6068 arg1 = reinterpret_cast< wxPoint * >(argp1);
6069 {
6070 arg2 = &temp2;
6071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6072 }
6073 {
6074 {
6075 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6076 result = (wxPoint *) &_result_ref;
6077 }
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 wxPoint *arg1 = (wxPoint *) 0 ;
6090 wxPoint *arg2 = 0 ;
6091 wxPoint *result = 0 ;
6092 void *argp1 = 0 ;
6093 int res1 = 0 ;
6094 wxPoint temp2 ;
6095 PyObject * obj0 = 0 ;
6096 PyObject * obj1 = 0 ;
6097 char * kwnames[] = {
6098 (char *) "self",(char *) "pt", NULL
6099 };
6100
6101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6105 }
6106 arg1 = reinterpret_cast< wxPoint * >(argp1);
6107 {
6108 arg2 = &temp2;
6109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6110 }
6111 {
6112 {
6113 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6114 result = (wxPoint *) &_result_ref;
6115 }
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj = 0;
6127 wxPoint *arg1 = (wxPoint *) 0 ;
6128 long arg2 ;
6129 long arg3 ;
6130 void *argp1 = 0 ;
6131 int res1 = 0 ;
6132 long val2 ;
6133 int ecode2 = 0 ;
6134 long val3 ;
6135 int ecode3 = 0 ;
6136 PyObject * obj0 = 0 ;
6137 PyObject * obj1 = 0 ;
6138 PyObject * obj2 = 0 ;
6139 char * kwnames[] = {
6140 (char *) "self",(char *) "x",(char *) "y", NULL
6141 };
6142
6143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6145 if (!SWIG_IsOK(res1)) {
6146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6147 }
6148 arg1 = reinterpret_cast< wxPoint * >(argp1);
6149 ecode2 = SWIG_AsVal_long(obj1, &val2);
6150 if (!SWIG_IsOK(ecode2)) {
6151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6152 }
6153 arg2 = static_cast< long >(val2);
6154 ecode3 = SWIG_AsVal_long(obj2, &val3);
6155 if (!SWIG_IsOK(ecode3)) {
6156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6157 }
6158 arg3 = static_cast< long >(val3);
6159 {
6160 wxPoint_Set(arg1,arg2,arg3);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 resultobj = SWIG_Py_Void();
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6171 PyObject *resultobj = 0;
6172 wxPoint *arg1 = (wxPoint *) 0 ;
6173 PyObject *result = 0 ;
6174 void *argp1 = 0 ;
6175 int res1 = 0 ;
6176 PyObject *swig_obj[1] ;
6177
6178 if (!args) SWIG_fail;
6179 swig_obj[0] = args;
6180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6181 if (!SWIG_IsOK(res1)) {
6182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6183 }
6184 arg1 = reinterpret_cast< wxPoint * >(argp1);
6185 {
6186 result = (PyObject *)wxPoint_Get(arg1);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 resultobj = result;
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6197 PyObject *obj;
6198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6199 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6200 return SWIG_Py_Void();
6201 }
6202
6203 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6204 return SWIG_Python_InitShadowInstance(args);
6205 }
6206
6207 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj = 0;
6209 int arg1 = (int) 0 ;
6210 int arg2 = (int) 0 ;
6211 int arg3 = (int) 0 ;
6212 int arg4 = (int) 0 ;
6213 wxRect *result = 0 ;
6214 int val1 ;
6215 int ecode1 = 0 ;
6216 int val2 ;
6217 int ecode2 = 0 ;
6218 int val3 ;
6219 int ecode3 = 0 ;
6220 int val4 ;
6221 int ecode4 = 0 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 PyObject * obj2 = 0 ;
6225 PyObject * obj3 = 0 ;
6226 char * kwnames[] = {
6227 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6228 };
6229
6230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6231 if (obj0) {
6232 ecode1 = SWIG_AsVal_int(obj0, &val1);
6233 if (!SWIG_IsOK(ecode1)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6235 }
6236 arg1 = static_cast< int >(val1);
6237 }
6238 if (obj1) {
6239 ecode2 = SWIG_AsVal_int(obj1, &val2);
6240 if (!SWIG_IsOK(ecode2)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6242 }
6243 arg2 = static_cast< int >(val2);
6244 }
6245 if (obj2) {
6246 ecode3 = SWIG_AsVal_int(obj2, &val3);
6247 if (!SWIG_IsOK(ecode3)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6249 }
6250 arg3 = static_cast< int >(val3);
6251 }
6252 if (obj3) {
6253 ecode4 = SWIG_AsVal_int(obj3, &val4);
6254 if (!SWIG_IsOK(ecode4)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6256 }
6257 arg4 = static_cast< int >(val4);
6258 }
6259 {
6260 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj = 0;
6272 wxPoint *arg1 = 0 ;
6273 wxPoint *arg2 = 0 ;
6274 wxRect *result = 0 ;
6275 wxPoint temp1 ;
6276 wxPoint temp2 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char * kwnames[] = {
6280 (char *) "topLeft",(char *) "bottomRight", NULL
6281 };
6282
6283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6284 {
6285 arg1 = &temp1;
6286 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6287 }
6288 {
6289 arg2 = &temp2;
6290 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6291 }
6292 {
6293 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = 0;
6305 wxPoint *arg1 = 0 ;
6306 wxSize *arg2 = 0 ;
6307 wxRect *result = 0 ;
6308 wxPoint temp1 ;
6309 wxSize temp2 ;
6310 PyObject * obj0 = 0 ;
6311 PyObject * obj1 = 0 ;
6312 char * kwnames[] = {
6313 (char *) "pos",(char *) "size", NULL
6314 };
6315
6316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6317 {
6318 arg1 = &temp1;
6319 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6320 }
6321 {
6322 arg2 = &temp2;
6323 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6324 }
6325 {
6326 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj = 0;
6338 wxSize *arg1 = 0 ;
6339 wxRect *result = 0 ;
6340 wxSize temp1 ;
6341 PyObject * obj0 = 0 ;
6342 char * kwnames[] = {
6343 (char *) "size", NULL
6344 };
6345
6346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6347 {
6348 arg1 = &temp1;
6349 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6350 }
6351 {
6352 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6356 return resultobj;
6357 fail:
6358 return NULL;
6359 }
6360
6361
6362 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6363 PyObject *resultobj = 0;
6364 wxRect *arg1 = (wxRect *) 0 ;
6365 void *argp1 = 0 ;
6366 int res1 = 0 ;
6367 PyObject *swig_obj[1] ;
6368
6369 if (!args) SWIG_fail;
6370 swig_obj[0] = args;
6371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 {
6377 delete arg1;
6378
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 resultobj = SWIG_Py_Void();
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6389 PyObject *resultobj = 0;
6390 wxRect *arg1 = (wxRect *) 0 ;
6391 int result;
6392 void *argp1 = 0 ;
6393 int res1 = 0 ;
6394 PyObject *swig_obj[1] ;
6395
6396 if (!args) SWIG_fail;
6397 swig_obj[0] = args;
6398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6399 if (!SWIG_IsOK(res1)) {
6400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6401 }
6402 arg1 = reinterpret_cast< wxRect * >(argp1);
6403 {
6404 result = (int)((wxRect const *)arg1)->GetX();
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = SWIG_From_int(static_cast< int >(result));
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj = 0;
6416 wxRect *arg1 = (wxRect *) 0 ;
6417 int arg2 ;
6418 void *argp1 = 0 ;
6419 int res1 = 0 ;
6420 int val2 ;
6421 int ecode2 = 0 ;
6422 PyObject * obj0 = 0 ;
6423 PyObject * obj1 = 0 ;
6424 char * kwnames[] = {
6425 (char *) "self",(char *) "x", NULL
6426 };
6427
6428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6430 if (!SWIG_IsOK(res1)) {
6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6432 }
6433 arg1 = reinterpret_cast< wxRect * >(argp1);
6434 ecode2 = SWIG_AsVal_int(obj1, &val2);
6435 if (!SWIG_IsOK(ecode2)) {
6436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6437 }
6438 arg2 = static_cast< int >(val2);
6439 {
6440 (arg1)->SetX(arg2);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 resultobj = SWIG_Py_Void();
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6451 PyObject *resultobj = 0;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 int result;
6454 void *argp1 = 0 ;
6455 int res1 = 0 ;
6456 PyObject *swig_obj[1] ;
6457
6458 if (!args) SWIG_fail;
6459 swig_obj[0] = args;
6460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6461 if (!SWIG_IsOK(res1)) {
6462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6463 }
6464 arg1 = reinterpret_cast< wxRect * >(argp1);
6465 {
6466 result = (int)(arg1)->GetY();
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_From_int(static_cast< int >(result));
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int arg2 ;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 int val2 ;
6483 int ecode2 = 0 ;
6484 PyObject * obj0 = 0 ;
6485 PyObject * obj1 = 0 ;
6486 char * kwnames[] = {
6487 (char *) "self",(char *) "y", NULL
6488 };
6489
6490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6492 if (!SWIG_IsOK(res1)) {
6493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6494 }
6495 arg1 = reinterpret_cast< wxRect * >(argp1);
6496 ecode2 = SWIG_AsVal_int(obj1, &val2);
6497 if (!SWIG_IsOK(ecode2)) {
6498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6499 }
6500 arg2 = static_cast< int >(val2);
6501 {
6502 (arg1)->SetY(arg2);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 resultobj = SWIG_Py_Void();
6506 return resultobj;
6507 fail:
6508 return NULL;
6509 }
6510
6511
6512 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6513 PyObject *resultobj = 0;
6514 wxRect *arg1 = (wxRect *) 0 ;
6515 int result;
6516 void *argp1 = 0 ;
6517 int res1 = 0 ;
6518 PyObject *swig_obj[1] ;
6519
6520 if (!args) SWIG_fail;
6521 swig_obj[0] = args;
6522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6523 if (!SWIG_IsOK(res1)) {
6524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6525 }
6526 arg1 = reinterpret_cast< wxRect * >(argp1);
6527 {
6528 result = (int)((wxRect const *)arg1)->GetWidth();
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_From_int(static_cast< int >(result));
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 int arg2 ;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 int val2 ;
6545 int ecode2 = 0 ;
6546 PyObject * obj0 = 0 ;
6547 PyObject * obj1 = 0 ;
6548 char * kwnames[] = {
6549 (char *) "self",(char *) "w", NULL
6550 };
6551
6552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6554 if (!SWIG_IsOK(res1)) {
6555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6556 }
6557 arg1 = reinterpret_cast< wxRect * >(argp1);
6558 ecode2 = SWIG_AsVal_int(obj1, &val2);
6559 if (!SWIG_IsOK(ecode2)) {
6560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6561 }
6562 arg2 = static_cast< int >(val2);
6563 {
6564 (arg1)->SetWidth(arg2);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_Py_Void();
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 wxRect *arg1 = (wxRect *) 0 ;
6577 int result;
6578 void *argp1 = 0 ;
6579 int res1 = 0 ;
6580 PyObject *swig_obj[1] ;
6581
6582 if (!args) SWIG_fail;
6583 swig_obj[0] = args;
6584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 result = (int)((wxRect const *)arg1)->GetHeight();
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxRect *arg1 = (wxRect *) 0 ;
6603 int arg2 ;
6604 void *argp1 = 0 ;
6605 int res1 = 0 ;
6606 int val2 ;
6607 int ecode2 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char * kwnames[] = {
6611 (char *) "self",(char *) "h", NULL
6612 };
6613
6614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 ecode2 = SWIG_AsVal_int(obj1, &val2);
6621 if (!SWIG_IsOK(ecode2)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6623 }
6624 arg2 = static_cast< int >(val2);
6625 {
6626 (arg1)->SetHeight(arg2);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 resultobj = SWIG_Py_Void();
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6637 PyObject *resultobj = 0;
6638 wxRect *arg1 = (wxRect *) 0 ;
6639 wxPoint result;
6640 void *argp1 = 0 ;
6641 int res1 = 0 ;
6642 PyObject *swig_obj[1] ;
6643
6644 if (!args) SWIG_fail;
6645 swig_obj[0] = args;
6646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6649 }
6650 arg1 = reinterpret_cast< wxRect * >(argp1);
6651 {
6652 result = ((wxRect const *)arg1)->GetPosition();
6653 if (PyErr_Occurred()) SWIG_fail;
6654 }
6655 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj = 0;
6664 wxRect *arg1 = (wxRect *) 0 ;
6665 wxPoint *arg2 = 0 ;
6666 void *argp1 = 0 ;
6667 int res1 = 0 ;
6668 wxPoint temp2 ;
6669 PyObject * obj0 = 0 ;
6670 PyObject * obj1 = 0 ;
6671 char * kwnames[] = {
6672 (char *) "self",(char *) "p", NULL
6673 };
6674
6675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6677 if (!SWIG_IsOK(res1)) {
6678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6679 }
6680 arg1 = reinterpret_cast< wxRect * >(argp1);
6681 {
6682 arg2 = &temp2;
6683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6684 }
6685 {
6686 (arg1)->SetPosition((wxPoint const &)*arg2);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_Py_Void();
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxSize result;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 PyObject *swig_obj[1] ;
6703
6704 if (!args) SWIG_fail;
6705 swig_obj[0] = args;
6706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6709 }
6710 arg1 = reinterpret_cast< wxRect * >(argp1);
6711 {
6712 result = ((wxRect const *)arg1)->GetSize();
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj = 0;
6724 wxRect *arg1 = (wxRect *) 0 ;
6725 wxSize *arg2 = 0 ;
6726 void *argp1 = 0 ;
6727 int res1 = 0 ;
6728 wxSize temp2 ;
6729 PyObject * obj0 = 0 ;
6730 PyObject * obj1 = 0 ;
6731 char * kwnames[] = {
6732 (char *) "self",(char *) "s", NULL
6733 };
6734
6735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6737 if (!SWIG_IsOK(res1)) {
6738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6739 }
6740 arg1 = reinterpret_cast< wxRect * >(argp1);
6741 {
6742 arg2 = &temp2;
6743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6744 }
6745 {
6746 (arg1)->SetSize((wxSize const &)*arg2);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_Py_Void();
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxRect *arg1 = (wxRect *) 0 ;
6759 bool result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxRect * >(argp1);
6771 {
6772 result = (bool)((wxRect const *)arg1)->IsEmpty();
6773 if (PyErr_Occurred()) SWIG_fail;
6774 }
6775 {
6776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6777 }
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxRect *arg1 = (wxRect *) 0 ;
6787 wxPoint result;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject *swig_obj[1] ;
6791
6792 if (!args) SWIG_fail;
6793 swig_obj[0] = args;
6794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 result = ((wxRect const *)arg1)->GetTopLeft();
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj = 0;
6812 wxRect *arg1 = (wxRect *) 0 ;
6813 wxPoint *arg2 = 0 ;
6814 void *argp1 = 0 ;
6815 int res1 = 0 ;
6816 wxPoint temp2 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char * kwnames[] = {
6820 (char *) "self",(char *) "p", NULL
6821 };
6822
6823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 {
6830 arg2 = &temp2;
6831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6832 }
6833 {
6834 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_Py_Void();
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 wxPoint result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 result = ((wxRect const *)arg1)->GetBottomRight();
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj = 0;
6872 wxRect *arg1 = (wxRect *) 0 ;
6873 wxPoint *arg2 = 0 ;
6874 void *argp1 = 0 ;
6875 int res1 = 0 ;
6876 wxPoint temp2 ;
6877 PyObject * obj0 = 0 ;
6878 PyObject * obj1 = 0 ;
6879 char * kwnames[] = {
6880 (char *) "self",(char *) "p", NULL
6881 };
6882
6883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6887 }
6888 arg1 = reinterpret_cast< wxRect * >(argp1);
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_Py_Void();
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 PyObject *resultobj = 0;
6906 wxRect *arg1 = (wxRect *) 0 ;
6907 wxPoint result;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 PyObject *swig_obj[1] ;
6911
6912 if (!args) SWIG_fail;
6913 swig_obj[0] = args;
6914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6915 if (!SWIG_IsOK(res1)) {
6916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6917 }
6918 arg1 = reinterpret_cast< wxRect * >(argp1);
6919 {
6920 result = ((wxRect const *)arg1)->GetTopRight();
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj = 0;
6932 wxRect *arg1 = (wxRect *) 0 ;
6933 wxPoint *arg2 = 0 ;
6934 void *argp1 = 0 ;
6935 int res1 = 0 ;
6936 wxPoint temp2 ;
6937 PyObject * obj0 = 0 ;
6938 PyObject * obj1 = 0 ;
6939 char * kwnames[] = {
6940 (char *) "self",(char *) "p", NULL
6941 };
6942
6943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6945 if (!SWIG_IsOK(res1)) {
6946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6947 }
6948 arg1 = reinterpret_cast< wxRect * >(argp1);
6949 {
6950 arg2 = &temp2;
6951 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6952 }
6953 {
6954 (arg1)->SetTopRight((wxPoint const &)*arg2);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_Py_Void();
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6965 PyObject *resultobj = 0;
6966 wxRect *arg1 = (wxRect *) 0 ;
6967 wxPoint result;
6968 void *argp1 = 0 ;
6969 int res1 = 0 ;
6970 PyObject *swig_obj[1] ;
6971
6972 if (!args) SWIG_fail;
6973 swig_obj[0] = args;
6974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6977 }
6978 arg1 = reinterpret_cast< wxRect * >(argp1);
6979 {
6980 result = ((wxRect const *)arg1)->GetBottomLeft();
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj = 0;
6992 wxRect *arg1 = (wxRect *) 0 ;
6993 wxPoint *arg2 = 0 ;
6994 void *argp1 = 0 ;
6995 int res1 = 0 ;
6996 wxPoint temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char * kwnames[] = {
7000 (char *) "self",(char *) "p", NULL
7001 };
7002
7003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7005 if (!SWIG_IsOK(res1)) {
7006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7007 }
7008 arg1 = reinterpret_cast< wxRect * >(argp1);
7009 {
7010 arg2 = &temp2;
7011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7012 }
7013 {
7014 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_Py_Void();
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_Rect_GetLeft(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_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 {
7040 result = (int)((wxRect const *)arg1)->GetLeft();
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_From_int(static_cast< int >(result));
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7051 PyObject *resultobj = 0;
7052 wxRect *arg1 = (wxRect *) 0 ;
7053 int result;
7054 void *argp1 = 0 ;
7055 int res1 = 0 ;
7056 PyObject *swig_obj[1] ;
7057
7058 if (!args) SWIG_fail;
7059 swig_obj[0] = args;
7060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7061 if (!SWIG_IsOK(res1)) {
7062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7063 }
7064 arg1 = reinterpret_cast< wxRect * >(argp1);
7065 {
7066 result = (int)((wxRect const *)arg1)->GetTop();
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_From_int(static_cast< int >(result));
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int result;
7080 void *argp1 = 0 ;
7081 int res1 = 0 ;
7082 PyObject *swig_obj[1] ;
7083
7084 if (!args) SWIG_fail;
7085 swig_obj[0] = args;
7086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 {
7092 result = (int)((wxRect const *)arg1)->GetBottom();
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 resultobj = SWIG_From_int(static_cast< int >(result));
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7103 PyObject *resultobj = 0;
7104 wxRect *arg1 = (wxRect *) 0 ;
7105 int result;
7106 void *argp1 = 0 ;
7107 int res1 = 0 ;
7108 PyObject *swig_obj[1] ;
7109
7110 if (!args) SWIG_fail;
7111 swig_obj[0] = args;
7112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 {
7118 result = (int)((wxRect const *)arg1)->GetRight();
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_From_int(static_cast< int >(result));
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_SetLeft(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 *) "left", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",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_SetLeft" "', 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_SetLeft" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 {
7154 (arg1)->SetLeft(arg2);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_Py_Void();
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char * kwnames[] = {
7175 (char *) "self",(char *) "right", NULL
7176 };
7177
7178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7180 if (!SWIG_IsOK(res1)) {
7181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7182 }
7183 arg1 = reinterpret_cast< wxRect * >(argp1);
7184 ecode2 = SWIG_AsVal_int(obj1, &val2);
7185 if (!SWIG_IsOK(ecode2)) {
7186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7187 }
7188 arg2 = static_cast< int >(val2);
7189 {
7190 (arg1)->SetRight(arg2);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_Py_Void();
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj = 0;
7202 wxRect *arg1 = (wxRect *) 0 ;
7203 int arg2 ;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 int val2 ;
7207 int ecode2 = 0 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "self",(char *) "top", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7218 }
7219 arg1 = reinterpret_cast< wxRect * >(argp1);
7220 ecode2 = SWIG_AsVal_int(obj1, &val2);
7221 if (!SWIG_IsOK(ecode2)) {
7222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7223 }
7224 arg2 = static_cast< int >(val2);
7225 {
7226 (arg1)->SetTop(arg2);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 resultobj = SWIG_Py_Void();
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj = 0;
7238 wxRect *arg1 = (wxRect *) 0 ;
7239 int arg2 ;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 int val2 ;
7243 int ecode2 = 0 ;
7244 PyObject * obj0 = 0 ;
7245 PyObject * obj1 = 0 ;
7246 char * kwnames[] = {
7247 (char *) "self",(char *) "bottom", NULL
7248 };
7249
7250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7252 if (!SWIG_IsOK(res1)) {
7253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7254 }
7255 arg1 = reinterpret_cast< wxRect * >(argp1);
7256 ecode2 = SWIG_AsVal_int(obj1, &val2);
7257 if (!SWIG_IsOK(ecode2)) {
7258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7259 }
7260 arg2 = static_cast< int >(val2);
7261 {
7262 (arg1)->SetBottom(arg2);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = SWIG_Py_Void();
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj = 0;
7274 wxRect *arg1 = (wxRect *) 0 ;
7275 int arg2 ;
7276 int arg3 ;
7277 wxRect *result = 0 ;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 int val2 ;
7281 int ecode2 = 0 ;
7282 int val3 ;
7283 int ecode3 = 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 PyObject * obj2 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "dx",(char *) "dy", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 ecode2 = SWIG_AsVal_int(obj1, &val2);
7298 if (!SWIG_IsOK(ecode2)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7300 }
7301 arg2 = static_cast< int >(val2);
7302 ecode3 = SWIG_AsVal_int(obj2, &val3);
7303 if (!SWIG_IsOK(ecode3)) {
7304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7305 }
7306 arg3 = static_cast< int >(val3);
7307 {
7308 {
7309 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7310 result = (wxRect *) &_result_ref;
7311 }
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7322 PyObject *resultobj = 0;
7323 wxRect *arg1 = (wxRect *) 0 ;
7324 int arg2 ;
7325 int arg3 ;
7326 wxRect *result = 0 ;
7327 void *argp1 = 0 ;
7328 int res1 = 0 ;
7329 int val2 ;
7330 int ecode2 = 0 ;
7331 int val3 ;
7332 int ecode3 = 0 ;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 PyObject * obj2 = 0 ;
7336 char * kwnames[] = {
7337 (char *) "self",(char *) "dx",(char *) "dy", NULL
7338 };
7339
7340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7342 if (!SWIG_IsOK(res1)) {
7343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7344 }
7345 arg1 = reinterpret_cast< wxRect * >(argp1);
7346 ecode2 = SWIG_AsVal_int(obj1, &val2);
7347 if (!SWIG_IsOK(ecode2)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7349 }
7350 arg2 = static_cast< int >(val2);
7351 ecode3 = SWIG_AsVal_int(obj2, &val3);
7352 if (!SWIG_IsOK(ecode3)) {
7353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7354 }
7355 arg3 = static_cast< int >(val3);
7356 {
7357 {
7358 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7359 result = (wxRect *) &_result_ref;
7360 }
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj = 0;
7372 wxRect *arg1 = (wxRect *) 0 ;
7373 int arg2 ;
7374 int arg3 ;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 int val2 ;
7378 int ecode2 = 0 ;
7379 int val3 ;
7380 int ecode3 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 PyObject * obj2 = 0 ;
7384 char * kwnames[] = {
7385 (char *) "self",(char *) "dx",(char *) "dy", NULL
7386 };
7387
7388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7392 }
7393 arg1 = reinterpret_cast< wxRect * >(argp1);
7394 ecode2 = SWIG_AsVal_int(obj1, &val2);
7395 if (!SWIG_IsOK(ecode2)) {
7396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7397 }
7398 arg2 = static_cast< int >(val2);
7399 ecode3 = SWIG_AsVal_int(obj2, &val3);
7400 if (!SWIG_IsOK(ecode3)) {
7401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7402 }
7403 arg3 = static_cast< int >(val3);
7404 {
7405 (arg1)->Offset(arg2,arg3);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 resultobj = SWIG_Py_Void();
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 wxPoint *arg2 = 0 ;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 wxPoint temp2 ;
7422 PyObject * obj0 = 0 ;
7423 PyObject * obj1 = 0 ;
7424 char * kwnames[] = {
7425 (char *) "self",(char *) "pt", NULL
7426 };
7427
7428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7430 if (!SWIG_IsOK(res1)) {
7431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7432 }
7433 arg1 = reinterpret_cast< wxRect * >(argp1);
7434 {
7435 arg2 = &temp2;
7436 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7437 }
7438 {
7439 (arg1)->Offset((wxPoint const &)*arg2);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 resultobj = SWIG_Py_Void();
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxRect *arg1 = (wxRect *) 0 ;
7452 wxRect *arg2 = 0 ;
7453 wxRect result;
7454 void *argp1 = 0 ;
7455 int res1 = 0 ;
7456 wxRect temp2 ;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 char * kwnames[] = {
7460 (char *) "self",(char *) "rect", NULL
7461 };
7462
7463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7465 if (!SWIG_IsOK(res1)) {
7466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7467 }
7468 arg1 = reinterpret_cast< wxRect * >(argp1);
7469 {
7470 arg2 = &temp2;
7471 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7472 }
7473 {
7474 result = (arg1)->Intersect((wxRect const &)*arg2);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj = 0;
7486 wxRect *arg1 = (wxRect *) 0 ;
7487 wxRect *arg2 = 0 ;
7488 wxRect result;
7489 void *argp1 = 0 ;
7490 int res1 = 0 ;
7491 wxRect temp2 ;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char * kwnames[] = {
7495 (char *) "self",(char *) "rect", NULL
7496 };
7497
7498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7500 if (!SWIG_IsOK(res1)) {
7501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7502 }
7503 arg1 = reinterpret_cast< wxRect * >(argp1);
7504 {
7505 arg2 = &temp2;
7506 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7507 }
7508 {
7509 result = (arg1)->Union((wxRect const &)*arg2);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7520 PyObject *resultobj = 0;
7521 wxRect *arg1 = (wxRect *) 0 ;
7522 wxRect *arg2 = 0 ;
7523 wxRect result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 wxRect temp2 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char * kwnames[] = {
7530 (char *) "self",(char *) "rect", NULL
7531 };
7532
7533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7537 }
7538 arg1 = reinterpret_cast< wxRect * >(argp1);
7539 {
7540 arg2 = &temp2;
7541 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7542 }
7543 {
7544 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxRect *arg1 = (wxRect *) 0 ;
7557 wxRect *arg2 = 0 ;
7558 wxRect *result = 0 ;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 wxRect temp2 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "rect", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 {
7575 arg2 = &temp2;
7576 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7577 }
7578 {
7579 {
7580 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7581 result = (wxRect *) &_result_ref;
7582 }
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj = 0;
7594 wxRect *arg1 = (wxRect *) 0 ;
7595 PyObject *arg2 = (PyObject *) 0 ;
7596 bool result;
7597 void *argp1 = 0 ;
7598 int res1 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "other", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 arg2 = obj1;
7612 {
7613 result = (bool)wxRect___eq__(arg1,arg2);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 {
7617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7618 }
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = 0;
7627 wxRect *arg1 = (wxRect *) 0 ;
7628 PyObject *arg2 = (PyObject *) 0 ;
7629 bool result;
7630 void *argp1 = 0 ;
7631 int res1 = 0 ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char * kwnames[] = {
7635 (char *) "self",(char *) "other", NULL
7636 };
7637
7638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 arg2 = obj1;
7645 {
7646 result = (bool)wxRect___ne__(arg1,arg2);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 {
7650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7651 }
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7659 PyObject *resultobj = 0;
7660 wxRect *arg1 = (wxRect *) 0 ;
7661 int arg2 ;
7662 int arg3 ;
7663 bool result;
7664 void *argp1 = 0 ;
7665 int res1 = 0 ;
7666 int val2 ;
7667 int ecode2 = 0 ;
7668 int val3 ;
7669 int ecode3 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 PyObject * obj2 = 0 ;
7673 char * kwnames[] = {
7674 (char *) "self",(char *) "x",(char *) "y", NULL
7675 };
7676
7677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7679 if (!SWIG_IsOK(res1)) {
7680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7681 }
7682 arg1 = reinterpret_cast< wxRect * >(argp1);
7683 ecode2 = SWIG_AsVal_int(obj1, &val2);
7684 if (!SWIG_IsOK(ecode2)) {
7685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7686 }
7687 arg2 = static_cast< int >(val2);
7688 ecode3 = SWIG_AsVal_int(obj2, &val3);
7689 if (!SWIG_IsOK(ecode3)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7691 }
7692 arg3 = static_cast< int >(val3);
7693 {
7694 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj = 0;
7708 wxRect *arg1 = (wxRect *) 0 ;
7709 wxPoint *arg2 = 0 ;
7710 bool result;
7711 void *argp1 = 0 ;
7712 int res1 = 0 ;
7713 wxPoint temp2 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 char * kwnames[] = {
7717 (char *) "self",(char *) "pt", NULL
7718 };
7719
7720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7724 }
7725 arg1 = reinterpret_cast< wxRect * >(argp1);
7726 {
7727 arg2 = &temp2;
7728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7729 }
7730 {
7731 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7732 if (PyErr_Occurred()) SWIG_fail;
7733 }
7734 {
7735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7736 }
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj = 0;
7745 wxRect *arg1 = (wxRect *) 0 ;
7746 wxRect *arg2 = 0 ;
7747 bool result;
7748 void *argp1 = 0 ;
7749 int res1 = 0 ;
7750 wxRect temp2 ;
7751 PyObject * obj0 = 0 ;
7752 PyObject * obj1 = 0 ;
7753 char * kwnames[] = {
7754 (char *) "self",(char *) "rect", NULL
7755 };
7756
7757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7761 }
7762 arg1 = reinterpret_cast< wxRect * >(argp1);
7763 {
7764 arg2 = &temp2;
7765 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7766 }
7767 {
7768 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 {
7772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj = 0;
7782 wxRect *arg1 = (wxRect *) 0 ;
7783 wxRect *arg2 = 0 ;
7784 bool result;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 wxRect temp2 ;
7788 PyObject * obj0 = 0 ;
7789 PyObject * obj1 = 0 ;
7790 char * kwnames[] = {
7791 (char *) "self",(char *) "rect", NULL
7792 };
7793
7794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7798 }
7799 arg1 = reinterpret_cast< wxRect * >(argp1);
7800 {
7801 arg2 = &temp2;
7802 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7803 }
7804 {
7805 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7806 if (PyErr_Occurred()) SWIG_fail;
7807 }
7808 {
7809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7810 }
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7818 PyObject *resultobj = 0;
7819 wxRect *arg1 = (wxRect *) 0 ;
7820 wxRect *arg2 = 0 ;
7821 int arg3 = (int) wxBOTH ;
7822 wxRect result;
7823 void *argp1 = 0 ;
7824 int res1 = 0 ;
7825 wxRect temp2 ;
7826 int val3 ;
7827 int ecode3 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 PyObject * obj2 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "self",(char *) "r",(char *) "dir", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7839 }
7840 arg1 = reinterpret_cast< wxRect * >(argp1);
7841 {
7842 arg2 = &temp2;
7843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7844 }
7845 if (obj2) {
7846 ecode3 = SWIG_AsVal_int(obj2, &val3);
7847 if (!SWIG_IsOK(ecode3)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7849 }
7850 arg3 = static_cast< int >(val3);
7851 }
7852 {
7853 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7864 PyObject *resultobj = 0;
7865 wxRect *arg1 = (wxRect *) 0 ;
7866 int arg2 ;
7867 void *argp1 = 0 ;
7868 int res1 = 0 ;
7869 int val2 ;
7870 int ecode2 = 0 ;
7871 PyObject *swig_obj[2] ;
7872
7873 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7875 if (!SWIG_IsOK(res1)) {
7876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7877 }
7878 arg1 = reinterpret_cast< wxRect * >(argp1);
7879 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7880 if (!SWIG_IsOK(ecode2)) {
7881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7882 }
7883 arg2 = static_cast< int >(val2);
7884 if (arg1) (arg1)->x = arg2;
7885
7886 resultobj = SWIG_Py_Void();
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7894 PyObject *resultobj = 0;
7895 wxRect *arg1 = (wxRect *) 0 ;
7896 int result;
7897 void *argp1 = 0 ;
7898 int res1 = 0 ;
7899 PyObject *swig_obj[1] ;
7900
7901 if (!args) SWIG_fail;
7902 swig_obj[0] = args;
7903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7904 if (!SWIG_IsOK(res1)) {
7905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7906 }
7907 arg1 = reinterpret_cast< wxRect * >(argp1);
7908 result = (int) ((arg1)->x);
7909 resultobj = SWIG_From_int(static_cast< int >(result));
7910 return resultobj;
7911 fail:
7912 return NULL;
7913 }
7914
7915
7916 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7917 PyObject *resultobj = 0;
7918 wxRect *arg1 = (wxRect *) 0 ;
7919 int arg2 ;
7920 void *argp1 = 0 ;
7921 int res1 = 0 ;
7922 int val2 ;
7923 int ecode2 = 0 ;
7924 PyObject *swig_obj[2] ;
7925
7926 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7928 if (!SWIG_IsOK(res1)) {
7929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7930 }
7931 arg1 = reinterpret_cast< wxRect * >(argp1);
7932 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7933 if (!SWIG_IsOK(ecode2)) {
7934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7935 }
7936 arg2 = static_cast< int >(val2);
7937 if (arg1) (arg1)->y = arg2;
7938
7939 resultobj = SWIG_Py_Void();
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7947 PyObject *resultobj = 0;
7948 wxRect *arg1 = (wxRect *) 0 ;
7949 int result;
7950 void *argp1 = 0 ;
7951 int res1 = 0 ;
7952 PyObject *swig_obj[1] ;
7953
7954 if (!args) SWIG_fail;
7955 swig_obj[0] = args;
7956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7957 if (!SWIG_IsOK(res1)) {
7958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7959 }
7960 arg1 = reinterpret_cast< wxRect * >(argp1);
7961 result = (int) ((arg1)->y);
7962 resultobj = SWIG_From_int(static_cast< int >(result));
7963 return resultobj;
7964 fail:
7965 return NULL;
7966 }
7967
7968
7969 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7970 PyObject *resultobj = 0;
7971 wxRect *arg1 = (wxRect *) 0 ;
7972 int arg2 ;
7973 void *argp1 = 0 ;
7974 int res1 = 0 ;
7975 int val2 ;
7976 int ecode2 = 0 ;
7977 PyObject *swig_obj[2] ;
7978
7979 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7981 if (!SWIG_IsOK(res1)) {
7982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7983 }
7984 arg1 = reinterpret_cast< wxRect * >(argp1);
7985 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7986 if (!SWIG_IsOK(ecode2)) {
7987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7988 }
7989 arg2 = static_cast< int >(val2);
7990 if (arg1) (arg1)->width = arg2;
7991
7992 resultobj = SWIG_Py_Void();
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8000 PyObject *resultobj = 0;
8001 wxRect *arg1 = (wxRect *) 0 ;
8002 int result;
8003 void *argp1 = 0 ;
8004 int res1 = 0 ;
8005 PyObject *swig_obj[1] ;
8006
8007 if (!args) SWIG_fail;
8008 swig_obj[0] = args;
8009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8010 if (!SWIG_IsOK(res1)) {
8011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8012 }
8013 arg1 = reinterpret_cast< wxRect * >(argp1);
8014 result = (int) ((arg1)->width);
8015 resultobj = SWIG_From_int(static_cast< int >(result));
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *resultobj = 0;
8024 wxRect *arg1 = (wxRect *) 0 ;
8025 int arg2 ;
8026 void *argp1 = 0 ;
8027 int res1 = 0 ;
8028 int val2 ;
8029 int ecode2 = 0 ;
8030 PyObject *swig_obj[2] ;
8031
8032 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8034 if (!SWIG_IsOK(res1)) {
8035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8036 }
8037 arg1 = reinterpret_cast< wxRect * >(argp1);
8038 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8039 if (!SWIG_IsOK(ecode2)) {
8040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8041 }
8042 arg2 = static_cast< int >(val2);
8043 if (arg1) (arg1)->height = arg2;
8044
8045 resultobj = SWIG_Py_Void();
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8053 PyObject *resultobj = 0;
8054 wxRect *arg1 = (wxRect *) 0 ;
8055 int result;
8056 void *argp1 = 0 ;
8057 int res1 = 0 ;
8058 PyObject *swig_obj[1] ;
8059
8060 if (!args) SWIG_fail;
8061 swig_obj[0] = args;
8062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8063 if (!SWIG_IsOK(res1)) {
8064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8065 }
8066 arg1 = reinterpret_cast< wxRect * >(argp1);
8067 result = (int) ((arg1)->height);
8068 resultobj = SWIG_From_int(static_cast< int >(result));
8069 return resultobj;
8070 fail:
8071 return NULL;
8072 }
8073
8074
8075 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8076 PyObject *resultobj = 0;
8077 wxRect *arg1 = (wxRect *) 0 ;
8078 int arg2 = (int) 0 ;
8079 int arg3 = (int) 0 ;
8080 int arg4 = (int) 0 ;
8081 int arg5 = (int) 0 ;
8082 void *argp1 = 0 ;
8083 int res1 = 0 ;
8084 int val2 ;
8085 int ecode2 = 0 ;
8086 int val3 ;
8087 int ecode3 = 0 ;
8088 int val4 ;
8089 int ecode4 = 0 ;
8090 int val5 ;
8091 int ecode5 = 0 ;
8092 PyObject * obj0 = 0 ;
8093 PyObject * obj1 = 0 ;
8094 PyObject * obj2 = 0 ;
8095 PyObject * obj3 = 0 ;
8096 PyObject * obj4 = 0 ;
8097 char * kwnames[] = {
8098 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8099 };
8100
8101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8103 if (!SWIG_IsOK(res1)) {
8104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8105 }
8106 arg1 = reinterpret_cast< wxRect * >(argp1);
8107 if (obj1) {
8108 ecode2 = SWIG_AsVal_int(obj1, &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 }
8114 if (obj2) {
8115 ecode3 = SWIG_AsVal_int(obj2, &val3);
8116 if (!SWIG_IsOK(ecode3)) {
8117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8118 }
8119 arg3 = static_cast< int >(val3);
8120 }
8121 if (obj3) {
8122 ecode4 = SWIG_AsVal_int(obj3, &val4);
8123 if (!SWIG_IsOK(ecode4)) {
8124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8125 }
8126 arg4 = static_cast< int >(val4);
8127 }
8128 if (obj4) {
8129 ecode5 = SWIG_AsVal_int(obj4, &val5);
8130 if (!SWIG_IsOK(ecode5)) {
8131 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8132 }
8133 arg5 = static_cast< int >(val5);
8134 }
8135 {
8136 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxRect *arg1 = (wxRect *) 0 ;
8149 PyObject *result = 0 ;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 {
8162 result = (PyObject *)wxRect_Get(arg1);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = result;
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *obj;
8174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8175 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8176 return SWIG_Py_Void();
8177 }
8178
8179 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8180 return SWIG_Python_InitShadowInstance(args);
8181 }
8182
8183 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8184 PyObject *resultobj = 0;
8185 wxRect *arg1 = (wxRect *) 0 ;
8186 wxRect *arg2 = (wxRect *) 0 ;
8187 PyObject *result = 0 ;
8188 void *argp1 = 0 ;
8189 int res1 = 0 ;
8190 void *argp2 = 0 ;
8191 int res2 = 0 ;
8192 PyObject * obj0 = 0 ;
8193 PyObject * obj1 = 0 ;
8194 char * kwnames[] = {
8195 (char *) "r1",(char *) "r2", NULL
8196 };
8197
8198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8200 if (!SWIG_IsOK(res1)) {
8201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8202 }
8203 arg1 = reinterpret_cast< wxRect * >(argp1);
8204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8205 if (!SWIG_IsOK(res2)) {
8206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8207 }
8208 arg2 = reinterpret_cast< wxRect * >(argp2);
8209 {
8210 if (!wxPyCheckForApp()) SWIG_fail;
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (PyObject *)wxIntersectRect(arg1,arg2);
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 resultobj = result;
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8224 PyObject *resultobj = 0;
8225 double arg1 = (double) 0.0 ;
8226 double arg2 = (double) 0.0 ;
8227 wxPoint2D *result = 0 ;
8228 double val1 ;
8229 int ecode1 = 0 ;
8230 double val2 ;
8231 int ecode2 = 0 ;
8232 PyObject * obj0 = 0 ;
8233 PyObject * obj1 = 0 ;
8234 char * kwnames[] = {
8235 (char *) "x",(char *) "y", NULL
8236 };
8237
8238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8239 if (obj0) {
8240 ecode1 = SWIG_AsVal_double(obj0, &val1);
8241 if (!SWIG_IsOK(ecode1)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8243 }
8244 arg1 = static_cast< double >(val1);
8245 }
8246 if (obj1) {
8247 ecode2 = SWIG_AsVal_double(obj1, &val2);
8248 if (!SWIG_IsOK(ecode2)) {
8249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8250 }
8251 arg2 = static_cast< double >(val2);
8252 }
8253 {
8254 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj = 0;
8266 wxPoint2D *arg1 = 0 ;
8267 wxPoint2D *result = 0 ;
8268 wxPoint2D temp1 ;
8269 PyObject * obj0 = 0 ;
8270 char * kwnames[] = {
8271 (char *) "pt", NULL
8272 };
8273
8274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8275 {
8276 arg1 = &temp1;
8277 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8278 }
8279 {
8280 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj = 0;
8292 wxPoint *arg1 = 0 ;
8293 wxPoint2D *result = 0 ;
8294 wxPoint temp1 ;
8295 PyObject * obj0 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "pt", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8301 {
8302 arg1 = &temp1;
8303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8304 }
8305 {
8306 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8317 PyObject *resultobj = 0;
8318 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8319 void *argp1 = 0 ;
8320 int res1 = 0 ;
8321 PyObject *swig_obj[1] ;
8322
8323 if (!args) SWIG_fail;
8324 swig_obj[0] = args;
8325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8326 if (!SWIG_IsOK(res1)) {
8327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8328 }
8329 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8330 {
8331 delete arg1;
8332
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 resultobj = SWIG_Py_Void();
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8343 PyObject *resultobj = 0;
8344 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8345 int *arg2 = (int *) 0 ;
8346 int *arg3 = (int *) 0 ;
8347 void *argp1 = 0 ;
8348 int res1 = 0 ;
8349 int temp2 ;
8350 int res2 = SWIG_TMPOBJ ;
8351 int temp3 ;
8352 int res3 = SWIG_TMPOBJ ;
8353 PyObject *swig_obj[1] ;
8354
8355 arg2 = &temp2;
8356 arg3 = &temp3;
8357 if (!args) SWIG_fail;
8358 swig_obj[0] = args;
8359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8360 if (!SWIG_IsOK(res1)) {
8361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8362 }
8363 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8364 {
8365 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 resultobj = SWIG_Py_Void();
8369 if (SWIG_IsTmpObj(res2)) {
8370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8371 } else {
8372 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8374 }
8375 if (SWIG_IsTmpObj(res3)) {
8376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8377 } else {
8378 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8380 }
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8388 PyObject *resultobj = 0;
8389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8390 int *arg2 = (int *) 0 ;
8391 int *arg3 = (int *) 0 ;
8392 void *argp1 = 0 ;
8393 int res1 = 0 ;
8394 int temp2 ;
8395 int res2 = SWIG_TMPOBJ ;
8396 int temp3 ;
8397 int res3 = SWIG_TMPOBJ ;
8398 PyObject *swig_obj[1] ;
8399
8400 arg2 = &temp2;
8401 arg3 = &temp3;
8402 if (!args) SWIG_fail;
8403 swig_obj[0] = args;
8404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_Py_Void();
8414 if (SWIG_IsTmpObj(res2)) {
8415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8416 } else {
8417 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8419 }
8420 if (SWIG_IsTmpObj(res3)) {
8421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8422 } else {
8423 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8425 }
8426 return resultobj;
8427 fail:
8428 return NULL;
8429 }
8430
8431
8432 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8433 PyObject *resultobj = 0;
8434 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8435 double result;
8436 void *argp1 = 0 ;
8437 int res1 = 0 ;
8438 PyObject *swig_obj[1] ;
8439
8440 if (!args) SWIG_fail;
8441 swig_obj[0] = args;
8442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8443 if (!SWIG_IsOK(res1)) {
8444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8445 }
8446 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8447 {
8448 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_From_double(static_cast< double >(result));
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 double result;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 PyObject *swig_obj[1] ;
8465
8466 if (!args) SWIG_fail;
8467 swig_obj[0] = args;
8468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8469 if (!SWIG_IsOK(res1)) {
8470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8471 }
8472 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8473 {
8474 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 resultobj = SWIG_From_double(static_cast< double >(result));
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj = 0;
8486 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8487 double arg2 ;
8488 void *argp1 = 0 ;
8489 int res1 = 0 ;
8490 double val2 ;
8491 int ecode2 = 0 ;
8492 PyObject * obj0 = 0 ;
8493 PyObject * obj1 = 0 ;
8494 char * kwnames[] = {
8495 (char *) "self",(char *) "length", NULL
8496 };
8497
8498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8500 if (!SWIG_IsOK(res1)) {
8501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8502 }
8503 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8504 ecode2 = SWIG_AsVal_double(obj1, &val2);
8505 if (!SWIG_IsOK(ecode2)) {
8506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8507 }
8508 arg2 = static_cast< double >(val2);
8509 {
8510 (arg1)->SetVectorLength(arg2);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 resultobj = SWIG_Py_Void();
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8521 PyObject *resultobj = 0;
8522 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8523 double arg2 ;
8524 void *argp1 = 0 ;
8525 int res1 = 0 ;
8526 double val2 ;
8527 int ecode2 = 0 ;
8528 PyObject * obj0 = 0 ;
8529 PyObject * obj1 = 0 ;
8530 char * kwnames[] = {
8531 (char *) "self",(char *) "degrees", NULL
8532 };
8533
8534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8536 if (!SWIG_IsOK(res1)) {
8537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8538 }
8539 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8540 ecode2 = SWIG_AsVal_double(obj1, &val2);
8541 if (!SWIG_IsOK(ecode2)) {
8542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8543 }
8544 arg2 = static_cast< double >(val2);
8545 {
8546 (arg1)->SetVectorAngle(arg2);
8547 if (PyErr_Occurred()) SWIG_fail;
8548 }
8549 resultobj = SWIG_Py_Void();
8550 return resultobj;
8551 fail:
8552 return NULL;
8553 }
8554
8555
8556 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj = 0;
8558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8559 wxPoint2D *arg2 = 0 ;
8560 double result;
8561 void *argp1 = 0 ;
8562 int res1 = 0 ;
8563 wxPoint2D temp2 ;
8564 PyObject * obj0 = 0 ;
8565 PyObject * obj1 = 0 ;
8566 char * kwnames[] = {
8567 (char *) "self",(char *) "pt", NULL
8568 };
8569
8570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8574 }
8575 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8576 {
8577 arg2 = &temp2;
8578 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8579 }
8580 {
8581 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 resultobj = SWIG_From_double(static_cast< double >(result));
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj = 0;
8593 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8594 wxPoint2D *arg2 = 0 ;
8595 double result;
8596 void *argp1 = 0 ;
8597 int res1 = 0 ;
8598 wxPoint2D temp2 ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char * kwnames[] = {
8602 (char *) "self",(char *) "pt", NULL
8603 };
8604
8605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8607 if (!SWIG_IsOK(res1)) {
8608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8609 }
8610 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8611 {
8612 arg2 = &temp2;
8613 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8614 }
8615 {
8616 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 resultobj = SWIG_From_double(static_cast< double >(result));
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj = 0;
8628 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8629 wxPoint2D *arg2 = 0 ;
8630 double result;
8631 void *argp1 = 0 ;
8632 int res1 = 0 ;
8633 wxPoint2D temp2 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "vec", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8644 }
8645 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8646 {
8647 arg2 = &temp2;
8648 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8649 }
8650 {
8651 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 resultobj = SWIG_From_double(static_cast< double >(result));
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8662 PyObject *resultobj = 0;
8663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8664 wxPoint2D *arg2 = 0 ;
8665 double result;
8666 void *argp1 = 0 ;
8667 int res1 = 0 ;
8668 wxPoint2D temp2 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 char * kwnames[] = {
8672 (char *) "self",(char *) "vec", NULL
8673 };
8674
8675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8679 }
8680 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8681 {
8682 arg2 = &temp2;
8683 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8684 }
8685 {
8686 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 resultobj = SWIG_From_double(static_cast< double >(result));
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8697 PyObject *resultobj = 0;
8698 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8699 wxPoint2D result;
8700 void *argp1 = 0 ;
8701 int res1 = 0 ;
8702 PyObject *swig_obj[1] ;
8703
8704 if (!args) SWIG_fail;
8705 swig_obj[0] = args;
8706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8707 if (!SWIG_IsOK(res1)) {
8708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8709 }
8710 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8711 {
8712 result = (arg1)->operator -();
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8716 return resultobj;
8717 fail:
8718 return NULL;
8719 }
8720
8721
8722 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8723 PyObject *resultobj = 0;
8724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8725 wxPoint2D *arg2 = 0 ;
8726 wxPoint2D *result = 0 ;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 wxPoint2D temp2 ;
8730 PyObject * obj0 = 0 ;
8731 PyObject * obj1 = 0 ;
8732 char * kwnames[] = {
8733 (char *) "self",(char *) "pt", NULL
8734 };
8735
8736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8738 if (!SWIG_IsOK(res1)) {
8739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8740 }
8741 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8742 {
8743 arg2 = &temp2;
8744 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8745 }
8746 {
8747 {
8748 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8749 result = (wxPoint2D *) &_result_ref;
8750 }
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8761 PyObject *resultobj = 0;
8762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8763 wxPoint2D *arg2 = 0 ;
8764 wxPoint2D *result = 0 ;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 wxPoint2D temp2 ;
8768 PyObject * obj0 = 0 ;
8769 PyObject * obj1 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "self",(char *) "pt", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8778 }
8779 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8780 {
8781 arg2 = &temp2;
8782 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8783 }
8784 {
8785 {
8786 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8787 result = (wxPoint2D *) &_result_ref;
8788 }
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj = 0;
8800 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8801 wxPoint2D *arg2 = 0 ;
8802 wxPoint2D *result = 0 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 wxPoint2D temp2 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 char * kwnames[] = {
8809 (char *) "self",(char *) "pt", NULL
8810 };
8811
8812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8814 if (!SWIG_IsOK(res1)) {
8815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8816 }
8817 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8818 {
8819 arg2 = &temp2;
8820 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8821 }
8822 {
8823 {
8824 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8825 result = (wxPoint2D *) &_result_ref;
8826 }
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj = 0;
8838 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8839 wxPoint2D *arg2 = 0 ;
8840 wxPoint2D *result = 0 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 wxPoint2D temp2 ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 char * kwnames[] = {
8847 (char *) "self",(char *) "pt", NULL
8848 };
8849
8850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 {
8857 arg2 = &temp2;
8858 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8859 }
8860 {
8861 {
8862 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8863 result = (wxPoint2D *) &_result_ref;
8864 }
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj = 0;
8876 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8877 PyObject *arg2 = (PyObject *) 0 ;
8878 bool result;
8879 void *argp1 = 0 ;
8880 int res1 = 0 ;
8881 PyObject * obj0 = 0 ;
8882 PyObject * obj1 = 0 ;
8883 char * kwnames[] = {
8884 (char *) "self",(char *) "other", NULL
8885 };
8886
8887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8889 if (!SWIG_IsOK(res1)) {
8890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8891 }
8892 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8893 arg2 = obj1;
8894 {
8895 result = (bool)wxPoint2D___eq__(arg1,arg2);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 {
8899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8900 }
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8910 PyObject *arg2 = (PyObject *) 0 ;
8911 bool result;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "other", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 arg2 = obj1;
8927 {
8928 result = (bool)wxPoint2D___ne__(arg1,arg2);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 {
8932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8933 }
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8941 PyObject *resultobj = 0;
8942 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8943 double arg2 ;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 double val2 ;
8947 int ecode2 = 0 ;
8948 PyObject *swig_obj[2] ;
8949
8950 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8956 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8957 if (!SWIG_IsOK(ecode2)) {
8958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8959 }
8960 arg2 = static_cast< double >(val2);
8961 if (arg1) (arg1)->m_x = arg2;
8962
8963 resultobj = SWIG_Py_Void();
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971 PyObject *resultobj = 0;
8972 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8973 double result;
8974 void *argp1 = 0 ;
8975 int res1 = 0 ;
8976 PyObject *swig_obj[1] ;
8977
8978 if (!args) SWIG_fail;
8979 swig_obj[0] = args;
8980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8981 if (!SWIG_IsOK(res1)) {
8982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8983 }
8984 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8985 result = (double) ((arg1)->m_x);
8986 resultobj = SWIG_From_double(static_cast< double >(result));
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 PyObject *resultobj = 0;
8995 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8996 double arg2 ;
8997 void *argp1 = 0 ;
8998 int res1 = 0 ;
8999 double val2 ;
9000 int ecode2 = 0 ;
9001 PyObject *swig_obj[2] ;
9002
9003 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9005 if (!SWIG_IsOK(res1)) {
9006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9007 }
9008 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9009 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9010 if (!SWIG_IsOK(ecode2)) {
9011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9012 }
9013 arg2 = static_cast< double >(val2);
9014 if (arg1) (arg1)->m_y = arg2;
9015
9016 resultobj = SWIG_Py_Void();
9017 return resultobj;
9018 fail:
9019 return NULL;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024 PyObject *resultobj = 0;
9025 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9026 double result;
9027 void *argp1 = 0 ;
9028 int res1 = 0 ;
9029 PyObject *swig_obj[1] ;
9030
9031 if (!args) SWIG_fail;
9032 swig_obj[0] = args;
9033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9038 result = (double) ((arg1)->m_y);
9039 resultobj = SWIG_From_double(static_cast< double >(result));
9040 return resultobj;
9041 fail:
9042 return NULL;
9043 }
9044
9045
9046 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj = 0;
9048 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9049 double arg2 = (double) 0 ;
9050 double arg3 = (double) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 double val2 ;
9054 int ecode2 = 0 ;
9055 double val3 ;
9056 int ecode3 = 0 ;
9057 PyObject * obj0 = 0 ;
9058 PyObject * obj1 = 0 ;
9059 PyObject * obj2 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "self",(char *) "x",(char *) "y", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9066 if (!SWIG_IsOK(res1)) {
9067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9068 }
9069 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9070 if (obj1) {
9071 ecode2 = SWIG_AsVal_double(obj1, &val2);
9072 if (!SWIG_IsOK(ecode2)) {
9073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9074 }
9075 arg2 = static_cast< double >(val2);
9076 }
9077 if (obj2) {
9078 ecode3 = SWIG_AsVal_double(obj2, &val3);
9079 if (!SWIG_IsOK(ecode3)) {
9080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9081 }
9082 arg3 = static_cast< double >(val3);
9083 }
9084 {
9085 wxPoint2D_Set(arg1,arg2,arg3);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 resultobj = SWIG_Py_Void();
9089 return resultobj;
9090 fail:
9091 return NULL;
9092 }
9093
9094
9095 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9096 PyObject *resultobj = 0;
9097 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9098 PyObject *result = 0 ;
9099 void *argp1 = 0 ;
9100 int res1 = 0 ;
9101 PyObject *swig_obj[1] ;
9102
9103 if (!args) SWIG_fail;
9104 swig_obj[0] = args;
9105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9106 if (!SWIG_IsOK(res1)) {
9107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9108 }
9109 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9110 {
9111 result = (PyObject *)wxPoint2D_Get(arg1);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 resultobj = result;
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 PyObject *obj;
9123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9124 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9125 return SWIG_Py_Void();
9126 }
9127
9128 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9129 return SWIG_Python_InitShadowInstance(args);
9130 }
9131
9132 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9133 PyObject *resultobj = 0;
9134 wxDouble arg1 = (wxDouble) 0.0 ;
9135 wxDouble arg2 = (wxDouble) 0.0 ;
9136 wxDouble arg3 = (wxDouble) 0.0 ;
9137 wxDouble arg4 = (wxDouble) 0.0 ;
9138 wxRect2D *result = 0 ;
9139 void *argp1 ;
9140 int res1 = 0 ;
9141 void *argp2 ;
9142 int res2 = 0 ;
9143 void *argp3 ;
9144 int res3 = 0 ;
9145 void *argp4 ;
9146 int res4 = 0 ;
9147 PyObject * obj0 = 0 ;
9148 PyObject * obj1 = 0 ;
9149 PyObject * obj2 = 0 ;
9150 PyObject * obj3 = 0 ;
9151 char * kwnames[] = {
9152 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9153 };
9154
9155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9156 if (obj0) {
9157 {
9158 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9161 }
9162 if (!argp1) {
9163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9164 } else {
9165 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9166 arg1 = *temp;
9167 if (SWIG_IsNewObj(res1)) delete temp;
9168 }
9169 }
9170 }
9171 if (obj1) {
9172 {
9173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9174 if (!SWIG_IsOK(res2)) {
9175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9176 }
9177 if (!argp2) {
9178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9179 } else {
9180 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9181 arg2 = *temp;
9182 if (SWIG_IsNewObj(res2)) delete temp;
9183 }
9184 }
9185 }
9186 if (obj2) {
9187 {
9188 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9189 if (!SWIG_IsOK(res3)) {
9190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9191 }
9192 if (!argp3) {
9193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9194 } else {
9195 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9196 arg3 = *temp;
9197 if (SWIG_IsNewObj(res3)) delete temp;
9198 }
9199 }
9200 }
9201 if (obj3) {
9202 {
9203 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9204 if (!SWIG_IsOK(res4)) {
9205 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9206 }
9207 if (!argp4) {
9208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9209 } else {
9210 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9211 arg4 = *temp;
9212 if (SWIG_IsNewObj(res4)) delete temp;
9213 }
9214 }
9215 }
9216 {
9217 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxRect2D *arg1 = (wxRect2D *) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9239 }
9240 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9241 {
9242 delete arg1;
9243
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_Py_Void();
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 PyObject *resultobj = 0;
9255 wxRect2D *arg1 = (wxRect2D *) 0 ;
9256 wxPoint2D result;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9266 }
9267 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9268 {
9269 result = (arg1)->GetPosition();
9270 if (PyErr_Occurred()) SWIG_fail;
9271 }
9272 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9273 return resultobj;
9274 fail:
9275 return NULL;
9276 }
9277
9278
9279 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9280 PyObject *resultobj = 0;
9281 wxRect2D *arg1 = (wxRect2D *) 0 ;
9282 wxSize result;
9283 void *argp1 = 0 ;
9284 int res1 = 0 ;
9285 PyObject *swig_obj[1] ;
9286
9287 if (!args) SWIG_fail;
9288 swig_obj[0] = args;
9289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9290 if (!SWIG_IsOK(res1)) {
9291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9292 }
9293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9294 {
9295 result = (arg1)->GetSize();
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9306 PyObject *resultobj = 0;
9307 wxRect2D *arg1 = (wxRect2D *) 0 ;
9308 wxDouble result;
9309 void *argp1 = 0 ;
9310 int res1 = 0 ;
9311 PyObject *swig_obj[1] ;
9312
9313 if (!args) SWIG_fail;
9314 swig_obj[0] = args;
9315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9316 if (!SWIG_IsOK(res1)) {
9317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9318 }
9319 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9320 {
9321 result = ((wxRect2D const *)arg1)->GetLeft();
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj = 0;
9333 wxRect2D *arg1 = (wxRect2D *) 0 ;
9334 wxDouble arg2 ;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 void *argp2 ;
9338 int res2 = 0 ;
9339 PyObject * obj0 = 0 ;
9340 PyObject * obj1 = 0 ;
9341 char * kwnames[] = {
9342 (char *) "self",(char *) "n", NULL
9343 };
9344
9345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9347 if (!SWIG_IsOK(res1)) {
9348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9349 }
9350 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9351 {
9352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9353 if (!SWIG_IsOK(res2)) {
9354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9355 }
9356 if (!argp2) {
9357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9358 } else {
9359 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9360 arg2 = *temp;
9361 if (SWIG_IsNewObj(res2)) delete temp;
9362 }
9363 }
9364 {
9365 (arg1)->SetLeft(arg2);
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 resultobj = SWIG_Py_Void();
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9376 PyObject *resultobj = 0;
9377 wxRect2D *arg1 = (wxRect2D *) 0 ;
9378 wxDouble arg2 ;
9379 void *argp1 = 0 ;
9380 int res1 = 0 ;
9381 void *argp2 ;
9382 int res2 = 0 ;
9383 PyObject * obj0 = 0 ;
9384 PyObject * obj1 = 0 ;
9385 char * kwnames[] = {
9386 (char *) "self",(char *) "n", NULL
9387 };
9388
9389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9391 if (!SWIG_IsOK(res1)) {
9392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9393 }
9394 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9395 {
9396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9397 if (!SWIG_IsOK(res2)) {
9398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9399 }
9400 if (!argp2) {
9401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9402 } else {
9403 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9404 arg2 = *temp;
9405 if (SWIG_IsNewObj(res2)) delete temp;
9406 }
9407 }
9408 {
9409 (arg1)->MoveLeftTo(arg2);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_Py_Void();
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9420 PyObject *resultobj = 0;
9421 wxRect2D *arg1 = (wxRect2D *) 0 ;
9422 wxDouble result;
9423 void *argp1 = 0 ;
9424 int res1 = 0 ;
9425 PyObject *swig_obj[1] ;
9426
9427 if (!args) SWIG_fail;
9428 swig_obj[0] = args;
9429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9430 if (!SWIG_IsOK(res1)) {
9431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9432 }
9433 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9434 {
9435 result = ((wxRect2D const *)arg1)->GetTop();
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxRect2D *arg1 = (wxRect2D *) 0 ;
9448 wxDouble arg2 ;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 void *argp2 ;
9452 int res2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "self",(char *) "n", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9463 }
9464 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9465 {
9466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9467 if (!SWIG_IsOK(res2)) {
9468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9469 }
9470 if (!argp2) {
9471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9472 } else {
9473 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9474 arg2 = *temp;
9475 if (SWIG_IsNewObj(res2)) delete temp;
9476 }
9477 }
9478 {
9479 (arg1)->SetTop(arg2);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxRect2D *arg1 = (wxRect2D *) 0 ;
9492 wxDouble arg2 ;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 void *argp2 ;
9496 int res2 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char * kwnames[] = {
9500 (char *) "self",(char *) "n", NULL
9501 };
9502
9503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9507 }
9508 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9509 {
9510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9511 if (!SWIG_IsOK(res2)) {
9512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9513 }
9514 if (!argp2) {
9515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9516 } else {
9517 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9518 arg2 = *temp;
9519 if (SWIG_IsNewObj(res2)) delete temp;
9520 }
9521 }
9522 {
9523 (arg1)->MoveTopTo(arg2);
9524 if (PyErr_Occurred()) SWIG_fail;
9525 }
9526 resultobj = SWIG_Py_Void();
9527 return resultobj;
9528 fail:
9529 return NULL;
9530 }
9531
9532
9533 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9534 PyObject *resultobj = 0;
9535 wxRect2D *arg1 = (wxRect2D *) 0 ;
9536 wxDouble result;
9537 void *argp1 = 0 ;
9538 int res1 = 0 ;
9539 PyObject *swig_obj[1] ;
9540
9541 if (!args) SWIG_fail;
9542 swig_obj[0] = args;
9543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9544 if (!SWIG_IsOK(res1)) {
9545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9546 }
9547 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9548 {
9549 result = ((wxRect2D const *)arg1)->GetBottom();
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj = 0;
9561 wxRect2D *arg1 = (wxRect2D *) 0 ;
9562 wxDouble arg2 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 void *argp2 ;
9566 int res2 = 0 ;
9567 PyObject * obj0 = 0 ;
9568 PyObject * obj1 = 0 ;
9569 char * kwnames[] = {
9570 (char *) "self",(char *) "n", NULL
9571 };
9572
9573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9575 if (!SWIG_IsOK(res1)) {
9576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9577 }
9578 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9579 {
9580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9581 if (!SWIG_IsOK(res2)) {
9582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9583 }
9584 if (!argp2) {
9585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9586 } else {
9587 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9588 arg2 = *temp;
9589 if (SWIG_IsNewObj(res2)) delete temp;
9590 }
9591 }
9592 {
9593 (arg1)->SetBottom(arg2);
9594 if (PyErr_Occurred()) SWIG_fail;
9595 }
9596 resultobj = SWIG_Py_Void();
9597 return resultobj;
9598 fail:
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9604 PyObject *resultobj = 0;
9605 wxRect2D *arg1 = (wxRect2D *) 0 ;
9606 wxDouble arg2 ;
9607 void *argp1 = 0 ;
9608 int res1 = 0 ;
9609 void *argp2 ;
9610 int res2 = 0 ;
9611 PyObject * obj0 = 0 ;
9612 PyObject * obj1 = 0 ;
9613 char * kwnames[] = {
9614 (char *) "self",(char *) "n", NULL
9615 };
9616
9617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9619 if (!SWIG_IsOK(res1)) {
9620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9621 }
9622 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9623 {
9624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9625 if (!SWIG_IsOK(res2)) {
9626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9627 }
9628 if (!argp2) {
9629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9630 } else {
9631 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9632 arg2 = *temp;
9633 if (SWIG_IsNewObj(res2)) delete temp;
9634 }
9635 }
9636 {
9637 (arg1)->MoveBottomTo(arg2);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 resultobj = SWIG_Py_Void();
9641 return resultobj;
9642 fail:
9643 return NULL;
9644 }
9645
9646
9647 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9648 PyObject *resultobj = 0;
9649 wxRect2D *arg1 = (wxRect2D *) 0 ;
9650 wxDouble result;
9651 void *argp1 = 0 ;
9652 int res1 = 0 ;
9653 PyObject *swig_obj[1] ;
9654
9655 if (!args) SWIG_fail;
9656 swig_obj[0] = args;
9657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9658 if (!SWIG_IsOK(res1)) {
9659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9660 }
9661 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9662 {
9663 result = ((wxRect2D const *)arg1)->GetRight();
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxRect2D *arg1 = (wxRect2D *) 0 ;
9676 wxDouble arg2 ;
9677 void *argp1 = 0 ;
9678 int res1 = 0 ;
9679 void *argp2 ;
9680 int res2 = 0 ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 char * kwnames[] = {
9684 (char *) "self",(char *) "n", NULL
9685 };
9686
9687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9689 if (!SWIG_IsOK(res1)) {
9690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9691 }
9692 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9693 {
9694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9695 if (!SWIG_IsOK(res2)) {
9696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9697 }
9698 if (!argp2) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9700 } else {
9701 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9702 arg2 = *temp;
9703 if (SWIG_IsNewObj(res2)) delete temp;
9704 }
9705 }
9706 {
9707 (arg1)->SetRight(arg2);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = SWIG_Py_Void();
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9718 PyObject *resultobj = 0;
9719 wxRect2D *arg1 = (wxRect2D *) 0 ;
9720 wxDouble arg2 ;
9721 void *argp1 = 0 ;
9722 int res1 = 0 ;
9723 void *argp2 ;
9724 int res2 = 0 ;
9725 PyObject * obj0 = 0 ;
9726 PyObject * obj1 = 0 ;
9727 char * kwnames[] = {
9728 (char *) "self",(char *) "n", NULL
9729 };
9730
9731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9733 if (!SWIG_IsOK(res1)) {
9734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9735 }
9736 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9737 {
9738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9739 if (!SWIG_IsOK(res2)) {
9740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9741 }
9742 if (!argp2) {
9743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9744 } else {
9745 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9746 arg2 = *temp;
9747 if (SWIG_IsNewObj(res2)) delete temp;
9748 }
9749 }
9750 {
9751 (arg1)->MoveRightTo(arg2);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 resultobj = SWIG_Py_Void();
9755 return resultobj;
9756 fail:
9757 return NULL;
9758 }
9759
9760
9761 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9762 PyObject *resultobj = 0;
9763 wxRect2D *arg1 = (wxRect2D *) 0 ;
9764 wxPoint2D result;
9765 void *argp1 = 0 ;
9766 int res1 = 0 ;
9767 PyObject *swig_obj[1] ;
9768
9769 if (!args) SWIG_fail;
9770 swig_obj[0] = args;
9771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9774 }
9775 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9776 {
9777 result = ((wxRect2D const *)arg1)->GetLeftTop();
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9788 PyObject *resultobj = 0;
9789 wxRect2D *arg1 = (wxRect2D *) 0 ;
9790 wxPoint2D *arg2 = 0 ;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 wxPoint2D temp2 ;
9794 PyObject * obj0 = 0 ;
9795 PyObject * obj1 = 0 ;
9796 char * kwnames[] = {
9797 (char *) "self",(char *) "pt", NULL
9798 };
9799
9800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9804 }
9805 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9806 {
9807 arg2 = &temp2;
9808 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9809 }
9810 {
9811 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 resultobj = SWIG_Py_Void();
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9822 PyObject *resultobj = 0;
9823 wxRect2D *arg1 = (wxRect2D *) 0 ;
9824 wxPoint2D *arg2 = 0 ;
9825 void *argp1 = 0 ;
9826 int res1 = 0 ;
9827 wxPoint2D temp2 ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 char * kwnames[] = {
9831 (char *) "self",(char *) "pt", NULL
9832 };
9833
9834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9836 if (!SWIG_IsOK(res1)) {
9837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9838 }
9839 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9840 {
9841 arg2 = &temp2;
9842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9843 }
9844 {
9845 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_Py_Void();
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9856 PyObject *resultobj = 0;
9857 wxRect2D *arg1 = (wxRect2D *) 0 ;
9858 wxPoint2D result;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject *swig_obj[1] ;
9862
9863 if (!args) SWIG_fail;
9864 swig_obj[0] = args;
9865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9870 {
9871 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = 0;
9883 wxRect2D *arg1 = (wxRect2D *) 0 ;
9884 wxPoint2D *arg2 = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 wxPoint2D temp2 ;
9888 PyObject * obj0 = 0 ;
9889 PyObject * obj1 = 0 ;
9890 char * kwnames[] = {
9891 (char *) "self",(char *) "pt", NULL
9892 };
9893
9894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9896 if (!SWIG_IsOK(res1)) {
9897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9898 }
9899 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9900 {
9901 arg2 = &temp2;
9902 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9903 }
9904 {
9905 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_Py_Void();
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = 0;
9917 wxRect2D *arg1 = (wxRect2D *) 0 ;
9918 wxPoint2D *arg2 = 0 ;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 wxPoint2D temp2 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "self",(char *) "pt", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9932 }
9933 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9934 {
9935 arg2 = &temp2;
9936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9937 }
9938 {
9939 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 resultobj = SWIG_Py_Void();
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 PyObject *resultobj = 0;
9951 wxRect2D *arg1 = (wxRect2D *) 0 ;
9952 wxPoint2D result;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 PyObject *swig_obj[1] ;
9956
9957 if (!args) SWIG_fail;
9958 swig_obj[0] = args;
9959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9962 }
9963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9964 {
9965 result = ((wxRect2D const *)arg1)->GetRightTop();
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj = 0;
9977 wxRect2D *arg1 = (wxRect2D *) 0 ;
9978 wxPoint2D *arg2 = 0 ;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 wxPoint2D temp2 ;
9982 PyObject * obj0 = 0 ;
9983 PyObject * obj1 = 0 ;
9984 char * kwnames[] = {
9985 (char *) "self",(char *) "pt", NULL
9986 };
9987
9988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9992 }
9993 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9994 {
9995 arg2 = &temp2;
9996 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9997 }
9998 {
9999 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_Py_Void();
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxRect2D *arg1 = (wxRect2D *) 0 ;
10012 wxPoint2D *arg2 = 0 ;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 wxPoint2D temp2 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "pt", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10026 }
10027 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10028 {
10029 arg2 = &temp2;
10030 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10031 }
10032 {
10033 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *resultobj = 0;
10045 wxRect2D *arg1 = (wxRect2D *) 0 ;
10046 wxPoint2D result;
10047 void *argp1 = 0 ;
10048 int res1 = 0 ;
10049 PyObject *swig_obj[1] ;
10050
10051 if (!args) SWIG_fail;
10052 swig_obj[0] = args;
10053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10054 if (!SWIG_IsOK(res1)) {
10055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10056 }
10057 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10058 {
10059 result = ((wxRect2D const *)arg1)->GetRightBottom();
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj = 0;
10071 wxRect2D *arg1 = (wxRect2D *) 0 ;
10072 wxPoint2D *arg2 = 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 wxPoint2D temp2 ;
10076 PyObject * obj0 = 0 ;
10077 PyObject * obj1 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "pt", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10086 }
10087 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10088 {
10089 arg2 = &temp2;
10090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10091 }
10092 {
10093 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxRect2D *arg1 = (wxRect2D *) 0 ;
10106 wxPoint2D *arg2 = 0 ;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 wxPoint2D temp2 ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "pt", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10120 }
10121 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10122 {
10123 arg2 = &temp2;
10124 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10125 }
10126 {
10127 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10128 if (PyErr_Occurred()) SWIG_fail;
10129 }
10130 resultobj = SWIG_Py_Void();
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10138 PyObject *resultobj = 0;
10139 wxRect2D *arg1 = (wxRect2D *) 0 ;
10140 wxPoint2D result;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 PyObject *swig_obj[1] ;
10144
10145 if (!args) SWIG_fail;
10146 swig_obj[0] = args;
10147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10150 }
10151 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10152 {
10153 result = ((wxRect2D const *)arg1)->GetCentre();
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxRect2D *arg1 = (wxRect2D *) 0 ;
10166 wxPoint2D *arg2 = 0 ;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 wxPoint2D temp2 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char * kwnames[] = {
10173 (char *) "self",(char *) "pt", NULL
10174 };
10175
10176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10180 }
10181 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10182 {
10183 arg2 = &temp2;
10184 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10185 }
10186 {
10187 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 resultobj = SWIG_Py_Void();
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxRect2D *arg1 = (wxRect2D *) 0 ;
10200 wxPoint2D *arg2 = 0 ;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 wxPoint2D temp2 ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char * kwnames[] = {
10207 (char *) "self",(char *) "pt", NULL
10208 };
10209
10210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10212 if (!SWIG_IsOK(res1)) {
10213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10214 }
10215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10216 {
10217 arg2 = &temp2;
10218 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10219 }
10220 {
10221 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 resultobj = SWIG_Py_Void();
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10232 PyObject *resultobj = 0;
10233 wxRect2D *arg1 = (wxRect2D *) 0 ;
10234 wxPoint2D *arg2 = 0 ;
10235 wxOutCode result;
10236 void *argp1 = 0 ;
10237 int res1 = 0 ;
10238 wxPoint2D temp2 ;
10239 PyObject * obj0 = 0 ;
10240 PyObject * obj1 = 0 ;
10241 char * kwnames[] = {
10242 (char *) "self",(char *) "pt", NULL
10243 };
10244
10245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10247 if (!SWIG_IsOK(res1)) {
10248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10249 }
10250 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10251 {
10252 arg2 = &temp2;
10253 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10254 }
10255 {
10256 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 resultobj = SWIG_From_int(static_cast< int >(result));
10260 return resultobj;
10261 fail:
10262 return NULL;
10263 }
10264
10265
10266 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj = 0;
10268 wxRect2D *arg1 = (wxRect2D *) 0 ;
10269 wxPoint2D *arg2 = 0 ;
10270 bool result;
10271 void *argp1 = 0 ;
10272 int res1 = 0 ;
10273 wxPoint2D temp2 ;
10274 PyObject * obj0 = 0 ;
10275 PyObject * obj1 = 0 ;
10276 char * kwnames[] = {
10277 (char *) "self",(char *) "pt", NULL
10278 };
10279
10280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10282 if (!SWIG_IsOK(res1)) {
10283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10284 }
10285 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10286 {
10287 arg2 = &temp2;
10288 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10289 }
10290 {
10291 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 {
10295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10296 }
10297 return resultobj;
10298 fail:
10299 return NULL;
10300 }
10301
10302
10303 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10304 PyObject *resultobj = 0;
10305 wxRect2D *arg1 = (wxRect2D *) 0 ;
10306 wxRect2D *arg2 = 0 ;
10307 bool result;
10308 void *argp1 = 0 ;
10309 int res1 = 0 ;
10310 wxRect2D temp2 ;
10311 PyObject * obj0 = 0 ;
10312 PyObject * obj1 = 0 ;
10313 char * kwnames[] = {
10314 (char *) "self",(char *) "rect", NULL
10315 };
10316
10317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10319 if (!SWIG_IsOK(res1)) {
10320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10321 }
10322 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10323 {
10324 arg2 = &temp2;
10325 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10326 }
10327 {
10328 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10329 if (PyErr_Occurred()) SWIG_fail;
10330 }
10331 {
10332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10333 }
10334 return resultobj;
10335 fail:
10336 return NULL;
10337 }
10338
10339
10340 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10341 PyObject *resultobj = 0;
10342 wxRect2D *arg1 = (wxRect2D *) 0 ;
10343 bool result;
10344 void *argp1 = 0 ;
10345 int res1 = 0 ;
10346 PyObject *swig_obj[1] ;
10347
10348 if (!args) SWIG_fail;
10349 swig_obj[0] = args;
10350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10351 if (!SWIG_IsOK(res1)) {
10352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10353 }
10354 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10355 {
10356 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 {
10360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10361 }
10362 return resultobj;
10363 fail:
10364 return NULL;
10365 }
10366
10367
10368 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj = 0;
10370 wxRect2D *arg1 = (wxRect2D *) 0 ;
10371 wxRect2D *arg2 = 0 ;
10372 bool result;
10373 void *argp1 = 0 ;
10374 int res1 = 0 ;
10375 wxRect2D temp2 ;
10376 PyObject * obj0 = 0 ;
10377 PyObject * obj1 = 0 ;
10378 char * kwnames[] = {
10379 (char *) "self",(char *) "rect", NULL
10380 };
10381
10382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10384 if (!SWIG_IsOK(res1)) {
10385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10386 }
10387 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10388 {
10389 arg2 = &temp2;
10390 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10391 }
10392 {
10393 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 {
10397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10398 }
10399 return resultobj;
10400 fail:
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10406 PyObject *resultobj = 0;
10407 wxRect2D *arg1 = (wxRect2D *) 0 ;
10408 wxDouble arg2 ;
10409 wxDouble arg3 ;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 void *argp2 ;
10413 int res2 = 0 ;
10414 void *argp3 ;
10415 int res3 = 0 ;
10416
10417 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10421 }
10422 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10423 {
10424 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10425 if (!SWIG_IsOK(res2)) {
10426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10427 }
10428 if (!argp2) {
10429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10430 } else {
10431 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10432 arg2 = *temp;
10433 if (SWIG_IsNewObj(res2)) delete temp;
10434 }
10435 }
10436 {
10437 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10438 if (!SWIG_IsOK(res3)) {
10439 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10440 }
10441 if (!argp3) {
10442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10443 } else {
10444 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10445 arg3 = *temp;
10446 if (SWIG_IsNewObj(res3)) delete temp;
10447 }
10448 }
10449 {
10450 (arg1)->Inset(arg2,arg3);
10451 if (PyErr_Occurred()) SWIG_fail;
10452 }
10453 resultobj = SWIG_Py_Void();
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10461 PyObject *resultobj = 0;
10462 wxRect2D *arg1 = (wxRect2D *) 0 ;
10463 wxDouble arg2 ;
10464 wxDouble arg3 ;
10465 wxDouble arg4 ;
10466 wxDouble arg5 ;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 void *argp2 ;
10470 int res2 = 0 ;
10471 void *argp3 ;
10472 int res3 = 0 ;
10473 void *argp4 ;
10474 int res4 = 0 ;
10475 void *argp5 ;
10476 int res5 = 0 ;
10477
10478 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10482 }
10483 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10484 {
10485 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10486 if (!SWIG_IsOK(res2)) {
10487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10488 }
10489 if (!argp2) {
10490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10491 } else {
10492 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10493 arg2 = *temp;
10494 if (SWIG_IsNewObj(res2)) delete temp;
10495 }
10496 }
10497 {
10498 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10499 if (!SWIG_IsOK(res3)) {
10500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10501 }
10502 if (!argp3) {
10503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10504 } else {
10505 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10506 arg3 = *temp;
10507 if (SWIG_IsNewObj(res3)) delete temp;
10508 }
10509 }
10510 {
10511 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10512 if (!SWIG_IsOK(res4)) {
10513 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10514 }
10515 if (!argp4) {
10516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10517 } else {
10518 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10519 arg4 = *temp;
10520 if (SWIG_IsNewObj(res4)) delete temp;
10521 }
10522 }
10523 {
10524 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10525 if (!SWIG_IsOK(res5)) {
10526 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10527 }
10528 if (!argp5) {
10529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10530 } else {
10531 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10532 arg5 = *temp;
10533 if (SWIG_IsNewObj(res5)) delete temp;
10534 }
10535 }
10536 {
10537 (arg1)->Inset(arg2,arg3,arg4,arg5);
10538 if (PyErr_Occurred()) SWIG_fail;
10539 }
10540 resultobj = SWIG_Py_Void();
10541 return resultobj;
10542 fail:
10543 return NULL;
10544 }
10545
10546
10547 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10548 int argc;
10549 PyObject *argv[6];
10550
10551 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10552 --argc;
10553 if (argc == 3) {
10554 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10555 }
10556 if (argc == 5) {
10557 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10558 }
10559
10560 fail:
10561 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10562 return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj = 0;
10568 wxRect2D *arg1 = (wxRect2D *) 0 ;
10569 wxPoint2D *arg2 = 0 ;
10570 void *argp1 = 0 ;
10571 int res1 = 0 ;
10572 wxPoint2D temp2 ;
10573 PyObject * obj0 = 0 ;
10574 PyObject * obj1 = 0 ;
10575 char * kwnames[] = {
10576 (char *) "self",(char *) "pt", NULL
10577 };
10578
10579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10581 if (!SWIG_IsOK(res1)) {
10582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10583 }
10584 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10585 {
10586 arg2 = &temp2;
10587 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10588 }
10589 {
10590 (arg1)->Offset((wxPoint2D const &)*arg2);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 resultobj = SWIG_Py_Void();
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj = 0;
10602 wxRect2D *arg1 = (wxRect2D *) 0 ;
10603 wxRect2D *arg2 = 0 ;
10604 void *argp1 = 0 ;
10605 int res1 = 0 ;
10606 wxRect2D temp2 ;
10607 PyObject * obj0 = 0 ;
10608 PyObject * obj1 = 0 ;
10609 char * kwnames[] = {
10610 (char *) "self",(char *) "rect", NULL
10611 };
10612
10613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10617 }
10618 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10619 {
10620 arg2 = &temp2;
10621 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10622 }
10623 {
10624 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 resultobj = SWIG_Py_Void();
10628 return resultobj;
10629 fail:
10630 return NULL;
10631 }
10632
10633
10634 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10635 PyObject *resultobj = 0;
10636 wxRect2D *arg1 = (wxRect2D *) 0 ;
10637 int arg2 ;
10638 int arg3 ;
10639 wxPoint2D result;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 int val2 ;
10643 int ecode2 = 0 ;
10644 int val3 ;
10645 int ecode3 = 0 ;
10646 PyObject * obj0 = 0 ;
10647 PyObject * obj1 = 0 ;
10648 PyObject * obj2 = 0 ;
10649 char * kwnames[] = {
10650 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10651 };
10652
10653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10657 }
10658 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10659 ecode2 = SWIG_AsVal_int(obj1, &val2);
10660 if (!SWIG_IsOK(ecode2)) {
10661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10662 }
10663 arg2 = static_cast< int >(val2);
10664 ecode3 = SWIG_AsVal_int(obj2, &val3);
10665 if (!SWIG_IsOK(ecode3)) {
10666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10667 }
10668 arg3 = static_cast< int >(val3);
10669 {
10670 result = (arg1)->Interpolate(arg2,arg3);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj = 0;
10682 wxRect2D *arg1 = (wxRect2D *) 0 ;
10683 wxRect2D *arg2 = 0 ;
10684 void *argp1 = 0 ;
10685 int res1 = 0 ;
10686 wxRect2D temp2 ;
10687 PyObject * obj0 = 0 ;
10688 PyObject * obj1 = 0 ;
10689 char * kwnames[] = {
10690 (char *) "self",(char *) "otherRect", NULL
10691 };
10692
10693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10695 if (!SWIG_IsOK(res1)) {
10696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10697 }
10698 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10699 {
10700 arg2 = &temp2;
10701 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10702 }
10703 {
10704 (arg1)->Intersect((wxRect2D const &)*arg2);
10705 if (PyErr_Occurred()) SWIG_fail;
10706 }
10707 resultobj = SWIG_Py_Void();
10708 return resultobj;
10709 fail:
10710 return NULL;
10711 }
10712
10713
10714 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10715 PyObject *resultobj = 0;
10716 wxRect2D *arg1 = (wxRect2D *) 0 ;
10717 wxRect2D *arg2 = 0 ;
10718 wxRect2D result;
10719 void *argp1 = 0 ;
10720 int res1 = 0 ;
10721 wxRect2D temp2 ;
10722 PyObject * obj0 = 0 ;
10723 PyObject * obj1 = 0 ;
10724 char * kwnames[] = {
10725 (char *) "self",(char *) "otherRect", NULL
10726 };
10727
10728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10730 if (!SWIG_IsOK(res1)) {
10731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10732 }
10733 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10734 {
10735 arg2 = &temp2;
10736 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10737 }
10738 {
10739 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10743 return resultobj;
10744 fail:
10745 return NULL;
10746 }
10747
10748
10749 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj = 0;
10751 wxRect2D *arg1 = (wxRect2D *) 0 ;
10752 wxRect2D *arg2 = 0 ;
10753 bool result;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 wxRect2D temp2 ;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 char * kwnames[] = {
10760 (char *) "self",(char *) "rect", NULL
10761 };
10762
10763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10767 }
10768 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10769 {
10770 arg2 = &temp2;
10771 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10772 }
10773 {
10774 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 {
10778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10779 }
10780 return resultobj;
10781 fail:
10782 return NULL;
10783 }
10784
10785
10786 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10787 PyObject *resultobj = 0;
10788 wxRect2D *arg1 = (wxRect2D *) 0 ;
10789 wxRect2D *arg2 = 0 ;
10790 void *argp1 = 0 ;
10791 int res1 = 0 ;
10792 wxRect2D temp2 ;
10793 PyObject * obj0 = 0 ;
10794 PyObject * obj1 = 0 ;
10795 char * kwnames[] = {
10796 (char *) "self",(char *) "otherRect", NULL
10797 };
10798
10799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10801 if (!SWIG_IsOK(res1)) {
10802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10803 }
10804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10805 {
10806 arg2 = &temp2;
10807 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10808 }
10809 {
10810 (arg1)->Union((wxRect2D const &)*arg2);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 resultobj = SWIG_Py_Void();
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj = 0;
10822 wxRect2D *arg1 = (wxRect2D *) 0 ;
10823 wxRect2D *arg2 = 0 ;
10824 wxRect2D result;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 wxRect2D temp2 ;
10828 PyObject * obj0 = 0 ;
10829 PyObject * obj1 = 0 ;
10830 char * kwnames[] = {
10831 (char *) "self",(char *) "otherRect", NULL
10832 };
10833
10834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10836 if (!SWIG_IsOK(res1)) {
10837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10838 }
10839 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10840 {
10841 arg2 = &temp2;
10842 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10843 }
10844 {
10845 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10856 PyObject *resultobj = 0;
10857 wxRect2D *arg1 = (wxRect2D *) 0 ;
10858 wxDouble arg2 ;
10859 void *argp1 = 0 ;
10860 int res1 = 0 ;
10861 void *argp2 ;
10862 int res2 = 0 ;
10863
10864 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10866 if (!SWIG_IsOK(res1)) {
10867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10868 }
10869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10870 {
10871 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10872 if (!SWIG_IsOK(res2)) {
10873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10874 }
10875 if (!argp2) {
10876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10877 } else {
10878 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10879 arg2 = *temp;
10880 if (SWIG_IsNewObj(res2)) delete temp;
10881 }
10882 }
10883 {
10884 (arg1)->Scale(arg2);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 resultobj = SWIG_Py_Void();
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10895 PyObject *resultobj = 0;
10896 wxRect2D *arg1 = (wxRect2D *) 0 ;
10897 int arg2 ;
10898 int arg3 ;
10899 void *argp1 = 0 ;
10900 int res1 = 0 ;
10901 int val2 ;
10902 int ecode2 = 0 ;
10903 int val3 ;
10904 int ecode3 = 0 ;
10905
10906 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10908 if (!SWIG_IsOK(res1)) {
10909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10910 }
10911 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10912 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10913 if (!SWIG_IsOK(ecode2)) {
10914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10915 }
10916 arg2 = static_cast< int >(val2);
10917 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10918 if (!SWIG_IsOK(ecode3)) {
10919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10920 }
10921 arg3 = static_cast< int >(val3);
10922 {
10923 (arg1)->Scale(arg2,arg3);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_Py_Void();
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10934 int argc;
10935 PyObject *argv[4];
10936
10937 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10938 --argc;
10939 if (argc == 2) {
10940 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10941 }
10942 if (argc == 3) {
10943 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10944 }
10945
10946 fail:
10947 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10948 return NULL;
10949 }
10950
10951
10952 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj = 0;
10954 wxRect2D *arg1 = (wxRect2D *) 0 ;
10955 PyObject *arg2 = (PyObject *) 0 ;
10956 bool result;
10957 void *argp1 = 0 ;
10958 int res1 = 0 ;
10959 PyObject * obj0 = 0 ;
10960 PyObject * obj1 = 0 ;
10961 char * kwnames[] = {
10962 (char *) "self",(char *) "other", NULL
10963 };
10964
10965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10967 if (!SWIG_IsOK(res1)) {
10968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10969 }
10970 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10971 arg2 = obj1;
10972 {
10973 result = (bool)wxRect2D___eq__(arg1,arg2);
10974 if (PyErr_Occurred()) SWIG_fail;
10975 }
10976 {
10977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10978 }
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj = 0;
10987 wxRect2D *arg1 = (wxRect2D *) 0 ;
10988 PyObject *arg2 = (PyObject *) 0 ;
10989 bool result;
10990 void *argp1 = 0 ;
10991 int res1 = 0 ;
10992 PyObject * obj0 = 0 ;
10993 PyObject * obj1 = 0 ;
10994 char * kwnames[] = {
10995 (char *) "self",(char *) "other", NULL
10996 };
10997
10998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11000 if (!SWIG_IsOK(res1)) {
11001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11002 }
11003 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11004 arg2 = obj1;
11005 {
11006 result = (bool)wxRect2D___ne__(arg1,arg2);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11011 }
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *resultobj = 0;
11020 wxRect2D *arg1 = (wxRect2D *) 0 ;
11021 wxDouble arg2 ;
11022 void *argp1 = 0 ;
11023 int res1 = 0 ;
11024 void *argp2 ;
11025 int res2 = 0 ;
11026 PyObject *swig_obj[2] ;
11027
11028 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11030 if (!SWIG_IsOK(res1)) {
11031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11032 }
11033 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11034 {
11035 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11036 if (!SWIG_IsOK(res2)) {
11037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11038 }
11039 if (!argp2) {
11040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11041 } else {
11042 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11043 arg2 = *temp;
11044 if (SWIG_IsNewObj(res2)) delete temp;
11045 }
11046 }
11047 if (arg1) (arg1)->m_x = arg2;
11048
11049 resultobj = SWIG_Py_Void();
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 PyObject *resultobj = 0;
11058 wxRect2D *arg1 = (wxRect2D *) 0 ;
11059 wxDouble result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 PyObject *swig_obj[1] ;
11063
11064 if (!args) SWIG_fail;
11065 swig_obj[0] = args;
11066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11067 if (!SWIG_IsOK(res1)) {
11068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11069 }
11070 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11071 result = ((arg1)->m_x);
11072 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11080 PyObject *resultobj = 0;
11081 wxRect2D *arg1 = (wxRect2D *) 0 ;
11082 wxDouble arg2 ;
11083 void *argp1 = 0 ;
11084 int res1 = 0 ;
11085 void *argp2 ;
11086 int res2 = 0 ;
11087 PyObject *swig_obj[2] ;
11088
11089 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11091 if (!SWIG_IsOK(res1)) {
11092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11093 }
11094 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11095 {
11096 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11097 if (!SWIG_IsOK(res2)) {
11098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11099 }
11100 if (!argp2) {
11101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11102 } else {
11103 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11104 arg2 = *temp;
11105 if (SWIG_IsNewObj(res2)) delete temp;
11106 }
11107 }
11108 if (arg1) (arg1)->m_y = arg2;
11109
11110 resultobj = SWIG_Py_Void();
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118 PyObject *resultobj = 0;
11119 wxRect2D *arg1 = (wxRect2D *) 0 ;
11120 wxDouble result;
11121 void *argp1 = 0 ;
11122 int res1 = 0 ;
11123 PyObject *swig_obj[1] ;
11124
11125 if (!args) SWIG_fail;
11126 swig_obj[0] = args;
11127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11128 if (!SWIG_IsOK(res1)) {
11129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11130 }
11131 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11132 result = ((arg1)->m_y);
11133 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxRect2D *arg1 = (wxRect2D *) 0 ;
11143 wxDouble arg2 ;
11144 void *argp1 = 0 ;
11145 int res1 = 0 ;
11146 void *argp2 ;
11147 int res2 = 0 ;
11148 PyObject *swig_obj[2] ;
11149
11150 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11152 if (!SWIG_IsOK(res1)) {
11153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11154 }
11155 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11156 {
11157 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11158 if (!SWIG_IsOK(res2)) {
11159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11160 }
11161 if (!argp2) {
11162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11163 } else {
11164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11165 arg2 = *temp;
11166 if (SWIG_IsNewObj(res2)) delete temp;
11167 }
11168 }
11169 if (arg1) (arg1)->m_width = arg2;
11170
11171 resultobj = SWIG_Py_Void();
11172 return resultobj;
11173 fail:
11174 return NULL;
11175 }
11176
11177
11178 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11179 PyObject *resultobj = 0;
11180 wxRect2D *arg1 = (wxRect2D *) 0 ;
11181 wxDouble result;
11182 void *argp1 = 0 ;
11183 int res1 = 0 ;
11184 PyObject *swig_obj[1] ;
11185
11186 if (!args) SWIG_fail;
11187 swig_obj[0] = args;
11188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11189 if (!SWIG_IsOK(res1)) {
11190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11191 }
11192 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11193 result = ((arg1)->m_width);
11194 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11202 PyObject *resultobj = 0;
11203 wxRect2D *arg1 = (wxRect2D *) 0 ;
11204 wxDouble arg2 ;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 void *argp2 ;
11208 int res2 = 0 ;
11209 PyObject *swig_obj[2] ;
11210
11211 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11213 if (!SWIG_IsOK(res1)) {
11214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11215 }
11216 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11217 {
11218 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11219 if (!SWIG_IsOK(res2)) {
11220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11221 }
11222 if (!argp2) {
11223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11224 } else {
11225 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11226 arg2 = *temp;
11227 if (SWIG_IsNewObj(res2)) delete temp;
11228 }
11229 }
11230 if (arg1) (arg1)->m_height = arg2;
11231
11232 resultobj = SWIG_Py_Void();
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11240 PyObject *resultobj = 0;
11241 wxRect2D *arg1 = (wxRect2D *) 0 ;
11242 wxDouble result;
11243 void *argp1 = 0 ;
11244 int res1 = 0 ;
11245 PyObject *swig_obj[1] ;
11246
11247 if (!args) SWIG_fail;
11248 swig_obj[0] = args;
11249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11250 if (!SWIG_IsOK(res1)) {
11251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11252 }
11253 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11254 result = ((arg1)->m_height);
11255 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11256 return resultobj;
11257 fail:
11258 return NULL;
11259 }
11260
11261
11262 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11263 PyObject *resultobj = 0;
11264 wxRect2D *arg1 = (wxRect2D *) 0 ;
11265 wxDouble arg2 = (wxDouble) 0 ;
11266 wxDouble arg3 = (wxDouble) 0 ;
11267 wxDouble arg4 = (wxDouble) 0 ;
11268 wxDouble arg5 = (wxDouble) 0 ;
11269 void *argp1 = 0 ;
11270 int res1 = 0 ;
11271 void *argp2 ;
11272 int res2 = 0 ;
11273 void *argp3 ;
11274 int res3 = 0 ;
11275 void *argp4 ;
11276 int res4 = 0 ;
11277 void *argp5 ;
11278 int res5 = 0 ;
11279 PyObject * obj0 = 0 ;
11280 PyObject * obj1 = 0 ;
11281 PyObject * obj2 = 0 ;
11282 PyObject * obj3 = 0 ;
11283 PyObject * obj4 = 0 ;
11284 char * kwnames[] = {
11285 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11286 };
11287
11288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11290 if (!SWIG_IsOK(res1)) {
11291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11292 }
11293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11294 if (obj1) {
11295 {
11296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11297 if (!SWIG_IsOK(res2)) {
11298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11299 }
11300 if (!argp2) {
11301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11302 } else {
11303 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11304 arg2 = *temp;
11305 if (SWIG_IsNewObj(res2)) delete temp;
11306 }
11307 }
11308 }
11309 if (obj2) {
11310 {
11311 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11312 if (!SWIG_IsOK(res3)) {
11313 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11314 }
11315 if (!argp3) {
11316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11317 } else {
11318 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11319 arg3 = *temp;
11320 if (SWIG_IsNewObj(res3)) delete temp;
11321 }
11322 }
11323 }
11324 if (obj3) {
11325 {
11326 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11327 if (!SWIG_IsOK(res4)) {
11328 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11329 }
11330 if (!argp4) {
11331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11332 } else {
11333 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11334 arg4 = *temp;
11335 if (SWIG_IsNewObj(res4)) delete temp;
11336 }
11337 }
11338 }
11339 if (obj4) {
11340 {
11341 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11342 if (!SWIG_IsOK(res5)) {
11343 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11344 }
11345 if (!argp5) {
11346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11347 } else {
11348 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11349 arg5 = *temp;
11350 if (SWIG_IsNewObj(res5)) delete temp;
11351 }
11352 }
11353 }
11354 {
11355 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 return resultobj;
11360 fail:
11361 return NULL;
11362 }
11363
11364
11365 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11366 PyObject *resultobj = 0;
11367 wxRect2D *arg1 = (wxRect2D *) 0 ;
11368 PyObject *result = 0 ;
11369 void *argp1 = 0 ;
11370 int res1 = 0 ;
11371 PyObject *swig_obj[1] ;
11372
11373 if (!args) SWIG_fail;
11374 swig_obj[0] = args;
11375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11376 if (!SWIG_IsOK(res1)) {
11377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11378 }
11379 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11380 {
11381 result = (PyObject *)wxRect2D_Get(arg1);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 resultobj = result;
11385 return resultobj;
11386 fail:
11387 return NULL;
11388 }
11389
11390
11391 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11392 PyObject *obj;
11393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11394 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11395 return SWIG_Py_Void();
11396 }
11397
11398 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11399 return SWIG_Python_InitShadowInstance(args);
11400 }
11401
11402 SWIGINTERN int DefaultPosition_set(PyObject *) {
11403 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11404 return 1;
11405 }
11406
11407
11408 SWIGINTERN PyObject *DefaultPosition_get(void) {
11409 PyObject *pyobj = 0;
11410
11411 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11412 return pyobj;
11413 }
11414
11415
11416 SWIGINTERN int DefaultSize_set(PyObject *) {
11417 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11418 return 1;
11419 }
11420
11421
11422 SWIGINTERN PyObject *DefaultSize_get(void) {
11423 PyObject *pyobj = 0;
11424
11425 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11426 return pyobj;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 PyObject *arg1 = (PyObject *) 0 ;
11433 wxPyInputStream *result = 0 ;
11434 PyObject * obj0 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "p", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11440 arg1 = obj0;
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11448 return resultobj;
11449 fail:
11450 return NULL;
11451 }
11452
11453
11454 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11455 PyObject *resultobj = 0;
11456 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11457 void *argp1 = 0 ;
11458 int res1 = 0 ;
11459 PyObject *swig_obj[1] ;
11460
11461 if (!args) SWIG_fail;
11462 swig_obj[0] = args;
11463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11464 if (!SWIG_IsOK(res1)) {
11465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11466 }
11467 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 delete arg1;
11471
11472 wxPyEndAllowThreads(__tstate);
11473 if (PyErr_Occurred()) SWIG_fail;
11474 }
11475 resultobj = SWIG_Py_Void();
11476 return resultobj;
11477 fail:
11478 return NULL;
11479 }
11480
11481
11482 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11483 PyObject *resultobj = 0;
11484 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11485 void *argp1 = 0 ;
11486 int res1 = 0 ;
11487 PyObject *swig_obj[1] ;
11488
11489 if (!args) SWIG_fail;
11490 swig_obj[0] = args;
11491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11492 if (!SWIG_IsOK(res1)) {
11493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11494 }
11495 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 (arg1)->close();
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 resultobj = SWIG_Py_Void();
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11510 PyObject *resultobj = 0;
11511 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 PyObject *swig_obj[1] ;
11515
11516 if (!args) SWIG_fail;
11517 swig_obj[0] = args;
11518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 (arg1)->flush();
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 resultobj = SWIG_Py_Void();
11530 return resultobj;
11531 fail:
11532 return NULL;
11533 }
11534
11535
11536 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11537 PyObject *resultobj = 0;
11538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11539 bool result;
11540 void *argp1 = 0 ;
11541 int res1 = 0 ;
11542 PyObject *swig_obj[1] ;
11543
11544 if (!args) SWIG_fail;
11545 swig_obj[0] = args;
11546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11547 if (!SWIG_IsOK(res1)) {
11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (bool)(arg1)->eof();
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11559 }
11560 return resultobj;
11561 fail:
11562 return NULL;
11563 }
11564
11565
11566 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj = 0;
11568 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11569 int arg2 = (int) -1 ;
11570 PyObject *result = 0 ;
11571 void *argp1 = 0 ;
11572 int res1 = 0 ;
11573 int val2 ;
11574 int ecode2 = 0 ;
11575 PyObject * obj0 = 0 ;
11576 PyObject * obj1 = 0 ;
11577 char * kwnames[] = {
11578 (char *) "self",(char *) "size", NULL
11579 };
11580
11581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11585 }
11586 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11587 if (obj1) {
11588 ecode2 = SWIG_AsVal_int(obj1, &val2);
11589 if (!SWIG_IsOK(ecode2)) {
11590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11591 }
11592 arg2 = static_cast< int >(val2);
11593 }
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 result = (PyObject *)(arg1)->read(arg2);
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 resultobj = result;
11601 return resultobj;
11602 fail:
11603 return NULL;
11604 }
11605
11606
11607 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11608 PyObject *resultobj = 0;
11609 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11610 int arg2 = (int) -1 ;
11611 PyObject *result = 0 ;
11612 void *argp1 = 0 ;
11613 int res1 = 0 ;
11614 int val2 ;
11615 int ecode2 = 0 ;
11616 PyObject * obj0 = 0 ;
11617 PyObject * obj1 = 0 ;
11618 char * kwnames[] = {
11619 (char *) "self",(char *) "size", NULL
11620 };
11621
11622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11624 if (!SWIG_IsOK(res1)) {
11625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11626 }
11627 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11628 if (obj1) {
11629 ecode2 = SWIG_AsVal_int(obj1, &val2);
11630 if (!SWIG_IsOK(ecode2)) {
11631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11632 }
11633 arg2 = static_cast< int >(val2);
11634 }
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (PyObject *)(arg1)->readline(arg2);
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 resultobj = result;
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11649 PyObject *resultobj = 0;
11650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11651 int arg2 = (int) -1 ;
11652 PyObject *result = 0 ;
11653 void *argp1 = 0 ;
11654 int res1 = 0 ;
11655 int val2 ;
11656 int ecode2 = 0 ;
11657 PyObject * obj0 = 0 ;
11658 PyObject * obj1 = 0 ;
11659 char * kwnames[] = {
11660 (char *) "self",(char *) "sizehint", NULL
11661 };
11662
11663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11665 if (!SWIG_IsOK(res1)) {
11666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11667 }
11668 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11669 if (obj1) {
11670 ecode2 = SWIG_AsVal_int(obj1, &val2);
11671 if (!SWIG_IsOK(ecode2)) {
11672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11673 }
11674 arg2 = static_cast< int >(val2);
11675 }
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 result = (PyObject *)(arg1)->readlines(arg2);
11679 wxPyEndAllowThreads(__tstate);
11680 if (PyErr_Occurred()) SWIG_fail;
11681 }
11682 resultobj = result;
11683 return resultobj;
11684 fail:
11685 return NULL;
11686 }
11687
11688
11689 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj = 0;
11691 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11692 int arg2 ;
11693 int arg3 = (int) 0 ;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 int val2 ;
11697 int ecode2 = 0 ;
11698 int val3 ;
11699 int ecode3 = 0 ;
11700 PyObject * obj0 = 0 ;
11701 PyObject * obj1 = 0 ;
11702 PyObject * obj2 = 0 ;
11703 char * kwnames[] = {
11704 (char *) "self",(char *) "offset",(char *) "whence", NULL
11705 };
11706
11707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11711 }
11712 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11713 ecode2 = SWIG_AsVal_int(obj1, &val2);
11714 if (!SWIG_IsOK(ecode2)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11716 }
11717 arg2 = static_cast< int >(val2);
11718 if (obj2) {
11719 ecode3 = SWIG_AsVal_int(obj2, &val3);
11720 if (!SWIG_IsOK(ecode3)) {
11721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11722 }
11723 arg3 = static_cast< int >(val3);
11724 }
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 (arg1)->seek(arg2,arg3);
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 resultobj = SWIG_Py_Void();
11732 return resultobj;
11733 fail:
11734 return NULL;
11735 }
11736
11737
11738 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 PyObject *resultobj = 0;
11740 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11741 int result;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 PyObject *swig_obj[1] ;
11745
11746 if (!args) SWIG_fail;
11747 swig_obj[0] = args;
11748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11751 }
11752 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (int)(arg1)->tell();
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 resultobj = SWIG_From_int(static_cast< int >(result));
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11767 PyObject *resultobj = 0;
11768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11769 char result;
11770 void *argp1 = 0 ;
11771 int res1 = 0 ;
11772 PyObject *swig_obj[1] ;
11773
11774 if (!args) SWIG_fail;
11775 swig_obj[0] = args;
11776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11777 if (!SWIG_IsOK(res1)) {
11778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11779 }
11780 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (char)(arg1)->Peek();
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 resultobj = SWIG_From_char(static_cast< char >(result));
11788 return resultobj;
11789 fail:
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11795 PyObject *resultobj = 0;
11796 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11797 char result;
11798 void *argp1 = 0 ;
11799 int res1 = 0 ;
11800 PyObject *swig_obj[1] ;
11801
11802 if (!args) SWIG_fail;
11803 swig_obj[0] = args;
11804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11805 if (!SWIG_IsOK(res1)) {
11806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11807 }
11808 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 result = (char)(arg1)->GetC();
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 resultobj = SWIG_From_char(static_cast< char >(result));
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11823 PyObject *resultobj = 0;
11824 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11825 size_t result;
11826 void *argp1 = 0 ;
11827 int res1 = 0 ;
11828 PyObject *swig_obj[1] ;
11829
11830 if (!args) SWIG_fail;
11831 swig_obj[0] = args;
11832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11835 }
11836 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (size_t)(arg1)->LastRead();
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11844 return resultobj;
11845 fail:
11846 return NULL;
11847 }
11848
11849
11850 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11851 PyObject *resultobj = 0;
11852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11853 bool result;
11854 void *argp1 = 0 ;
11855 int res1 = 0 ;
11856 PyObject *swig_obj[1] ;
11857
11858 if (!args) SWIG_fail;
11859 swig_obj[0] = args;
11860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11861 if (!SWIG_IsOK(res1)) {
11862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11863 }
11864 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = (bool)(arg1)->CanRead();
11868 wxPyEndAllowThreads(__tstate);
11869 if (PyErr_Occurred()) SWIG_fail;
11870 }
11871 {
11872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11873 }
11874 return resultobj;
11875 fail:
11876 return NULL;
11877 }
11878
11879
11880 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11881 PyObject *resultobj = 0;
11882 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11883 bool result;
11884 void *argp1 = 0 ;
11885 int res1 = 0 ;
11886 PyObject *swig_obj[1] ;
11887
11888 if (!args) SWIG_fail;
11889 swig_obj[0] = args;
11890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11891 if (!SWIG_IsOK(res1)) {
11892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11893 }
11894 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11895 {
11896 PyThreadState* __tstate = wxPyBeginAllowThreads();
11897 result = (bool)(arg1)->Eof();
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 {
11902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11903 }
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11911 PyObject *resultobj = 0;
11912 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11913 char arg2 ;
11914 bool result;
11915 void *argp1 = 0 ;
11916 int res1 = 0 ;
11917 char val2 ;
11918 int ecode2 = 0 ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 char * kwnames[] = {
11922 (char *) "self",(char *) "c", NULL
11923 };
11924
11925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11927 if (!SWIG_IsOK(res1)) {
11928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11929 }
11930 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11931 ecode2 = SWIG_AsVal_char(obj1, &val2);
11932 if (!SWIG_IsOK(ecode2)) {
11933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11934 }
11935 arg2 = static_cast< char >(val2);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->Ungetch(arg2);
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11952 PyObject *resultobj = 0;
11953 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11954 long arg2 ;
11955 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11956 long result;
11957 void *argp1 = 0 ;
11958 int res1 = 0 ;
11959 long val2 ;
11960 int ecode2 = 0 ;
11961 int val3 ;
11962 int ecode3 = 0 ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 PyObject * obj2 = 0 ;
11966 char * kwnames[] = {
11967 (char *) "self",(char *) "pos",(char *) "mode", NULL
11968 };
11969
11970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11972 if (!SWIG_IsOK(res1)) {
11973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11974 }
11975 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11976 ecode2 = SWIG_AsVal_long(obj1, &val2);
11977 if (!SWIG_IsOK(ecode2)) {
11978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11979 }
11980 arg2 = static_cast< long >(val2);
11981 if (obj2) {
11982 ecode3 = SWIG_AsVal_int(obj2, &val3);
11983 if (!SWIG_IsOK(ecode3)) {
11984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11985 }
11986 arg3 = static_cast< wxSeekMode >(val3);
11987 }
11988 {
11989 PyThreadState* __tstate = wxPyBeginAllowThreads();
11990 result = (long)(arg1)->SeekI(arg2,arg3);
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 resultobj = SWIG_From_long(static_cast< long >(result));
11995 return resultobj;
11996 fail:
11997 return NULL;
11998 }
11999
12000
12001 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12002 PyObject *resultobj = 0;
12003 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12004 long result;
12005 void *argp1 = 0 ;
12006 int res1 = 0 ;
12007 PyObject *swig_obj[1] ;
12008
12009 if (!args) SWIG_fail;
12010 swig_obj[0] = args;
12011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12012 if (!SWIG_IsOK(res1)) {
12013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12014 }
12015 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (long)(arg1)->TellI();
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 resultobj = SWIG_From_long(static_cast< long >(result));
12023 return resultobj;
12024 fail:
12025 return NULL;
12026 }
12027
12028
12029 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12030 PyObject *obj;
12031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12032 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12033 return SWIG_Py_Void();
12034 }
12035
12036 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12037 return SWIG_Python_InitShadowInstance(args);
12038 }
12039
12040 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = 0;
12042 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12043 PyObject *arg2 = (PyObject *) 0 ;
12044 void *argp1 = 0 ;
12045 int res1 = 0 ;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 char * kwnames[] = {
12049 (char *) "self",(char *) "obj", NULL
12050 };
12051
12052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12054 if (!SWIG_IsOK(res1)) {
12055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12056 }
12057 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12058 arg2 = obj1;
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 wxOutputStream_write(arg1,arg2);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_Py_Void();
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 PyObject *resultobj = 0;
12074 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12075 size_t result;
12076 void *argp1 = 0 ;
12077 int res1 = 0 ;
12078 PyObject *swig_obj[1] ;
12079
12080 if (!args) SWIG_fail;
12081 swig_obj[0] = args;
12082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12083 if (!SWIG_IsOK(res1)) {
12084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12085 }
12086 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *obj;
12102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12103 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12104 return SWIG_Py_Void();
12105 }
12106
12107 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj = 0;
12109 wxInputStream *arg1 = (wxInputStream *) 0 ;
12110 wxString *arg2 = 0 ;
12111 wxString *arg3 = 0 ;
12112 wxString *arg4 = 0 ;
12113 wxDateTime arg5 ;
12114 wxFSFile *result = 0 ;
12115 wxPyInputStream *temp1 ;
12116 bool temp2 = false ;
12117 bool temp3 = false ;
12118 bool temp4 = false ;
12119 void *argp5 ;
12120 int res5 = 0 ;
12121 PyObject * obj0 = 0 ;
12122 PyObject * obj1 = 0 ;
12123 PyObject * obj2 = 0 ;
12124 PyObject * obj3 = 0 ;
12125 PyObject * obj4 = 0 ;
12126 char * kwnames[] = {
12127 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12128 };
12129
12130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12131 {
12132 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12133 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12134 } else {
12135 PyErr_Clear(); // clear the failure of the wxPyConvert above
12136 arg1 = wxPyCBInputStream_create(obj0, true);
12137 if (arg1 == NULL) {
12138 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12139 SWIG_fail;
12140 }
12141 }
12142 }
12143 {
12144 arg2 = wxString_in_helper(obj1);
12145 if (arg2 == NULL) SWIG_fail;
12146 temp2 = true;
12147 }
12148 {
12149 arg3 = wxString_in_helper(obj2);
12150 if (arg3 == NULL) SWIG_fail;
12151 temp3 = true;
12152 }
12153 {
12154 arg4 = wxString_in_helper(obj3);
12155 if (arg4 == NULL) SWIG_fail;
12156 temp4 = true;
12157 }
12158 {
12159 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12160 if (!SWIG_IsOK(res5)) {
12161 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12162 }
12163 if (!argp5) {
12164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12165 } else {
12166 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12167 arg5 = *temp;
12168 if (SWIG_IsNewObj(res5)) delete temp;
12169 }
12170 }
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12174 wxPyEndAllowThreads(__tstate);
12175 if (PyErr_Occurred()) SWIG_fail;
12176 }
12177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12178 {
12179 if (temp2)
12180 delete arg2;
12181 }
12182 {
12183 if (temp3)
12184 delete arg3;
12185 }
12186 {
12187 if (temp4)
12188 delete arg4;
12189 }
12190 return resultobj;
12191 fail:
12192 {
12193 if (temp2)
12194 delete arg2;
12195 }
12196 {
12197 if (temp3)
12198 delete arg3;
12199 }
12200 {
12201 if (temp4)
12202 delete arg4;
12203 }
12204 return NULL;
12205 }
12206
12207
12208 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12209 PyObject *resultobj = 0;
12210 wxFSFile *arg1 = (wxFSFile *) 0 ;
12211 void *argp1 = 0 ;
12212 int res1 = 0 ;
12213 PyObject *swig_obj[1] ;
12214
12215 if (!args) SWIG_fail;
12216 swig_obj[0] = args;
12217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12218 if (!SWIG_IsOK(res1)) {
12219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12220 }
12221 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12222 {
12223 PyThreadState* __tstate = wxPyBeginAllowThreads();
12224 delete arg1;
12225
12226 wxPyEndAllowThreads(__tstate);
12227 if (PyErr_Occurred()) SWIG_fail;
12228 }
12229 resultobj = SWIG_Py_Void();
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12237 PyObject *resultobj = 0;
12238 wxFSFile *arg1 = (wxFSFile *) 0 ;
12239 wxInputStream *result = 0 ;
12240 void *argp1 = 0 ;
12241 int res1 = 0 ;
12242 PyObject *swig_obj[1] ;
12243
12244 if (!args) SWIG_fail;
12245 swig_obj[0] = args;
12246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12247 if (!SWIG_IsOK(res1)) {
12248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12249 }
12250 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (wxInputStream *)(arg1)->GetStream();
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 {
12258 wxPyInputStream * _ptr = NULL;
12259
12260 if (result) {
12261 _ptr = new wxPyInputStream(result);
12262 }
12263 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12264 }
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12272 PyObject *resultobj = 0;
12273 wxFSFile *arg1 = (wxFSFile *) 0 ;
12274 void *argp1 = 0 ;
12275 int res1 = 0 ;
12276 PyObject *swig_obj[1] ;
12277
12278 if (!args) SWIG_fail;
12279 swig_obj[0] = args;
12280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12281 if (!SWIG_IsOK(res1)) {
12282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12283 }
12284 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 (arg1)->DetachStream();
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_Py_Void();
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12299 PyObject *resultobj = 0;
12300 wxFSFile *arg1 = (wxFSFile *) 0 ;
12301 wxString *result = 0 ;
12302 void *argp1 = 0 ;
12303 int res1 = 0 ;
12304 PyObject *swig_obj[1] ;
12305
12306 if (!args) SWIG_fail;
12307 swig_obj[0] = args;
12308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12309 if (!SWIG_IsOK(res1)) {
12310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12311 }
12312 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 {
12316 wxString const &_result_ref = (arg1)->GetMimeType();
12317 result = (wxString *) &_result_ref;
12318 }
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 #if wxUSE_UNICODE
12324 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12325 #else
12326 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12327 #endif
12328 }
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12336 PyObject *resultobj = 0;
12337 wxFSFile *arg1 = (wxFSFile *) 0 ;
12338 wxString *result = 0 ;
12339 void *argp1 = 0 ;
12340 int res1 = 0 ;
12341 PyObject *swig_obj[1] ;
12342
12343 if (!args) SWIG_fail;
12344 swig_obj[0] = args;
12345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12346 if (!SWIG_IsOK(res1)) {
12347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12348 }
12349 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 {
12353 wxString const &_result_ref = (arg1)->GetLocation();
12354 result = (wxString *) &_result_ref;
12355 }
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 {
12360 #if wxUSE_UNICODE
12361 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12362 #else
12363 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12364 #endif
12365 }
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12373 PyObject *resultobj = 0;
12374 wxFSFile *arg1 = (wxFSFile *) 0 ;
12375 wxString *result = 0 ;
12376 void *argp1 = 0 ;
12377 int res1 = 0 ;
12378 PyObject *swig_obj[1] ;
12379
12380 if (!args) SWIG_fail;
12381 swig_obj[0] = args;
12382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12383 if (!SWIG_IsOK(res1)) {
12384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12385 }
12386 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12387 {
12388 PyThreadState* __tstate = wxPyBeginAllowThreads();
12389 {
12390 wxString const &_result_ref = (arg1)->GetAnchor();
12391 result = (wxString *) &_result_ref;
12392 }
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 {
12397 #if wxUSE_UNICODE
12398 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12399 #else
12400 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12401 #endif
12402 }
12403 return resultobj;
12404 fail:
12405 return NULL;
12406 }
12407
12408
12409 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12410 PyObject *resultobj = 0;
12411 wxFSFile *arg1 = (wxFSFile *) 0 ;
12412 wxDateTime result;
12413 void *argp1 = 0 ;
12414 int res1 = 0 ;
12415 PyObject *swig_obj[1] ;
12416
12417 if (!args) SWIG_fail;
12418 swig_obj[0] = args;
12419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12420 if (!SWIG_IsOK(res1)) {
12421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12422 }
12423 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 result = (arg1)->GetModificationTime();
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12438 PyObject *obj;
12439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12440 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12441 return SWIG_Py_Void();
12442 }
12443
12444 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12445 return SWIG_Python_InitShadowInstance(args);
12446 }
12447
12448 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12449 PyObject *resultobj = 0;
12450 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12451 void *argp1 = 0 ;
12452 int res1 = 0 ;
12453 PyObject *swig_obj[1] ;
12454
12455 if (!args) SWIG_fail;
12456 swig_obj[0] = args;
12457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12458 if (!SWIG_IsOK(res1)) {
12459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12460 }
12461 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 delete arg1;
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 resultobj = SWIG_Py_Void();
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12477 PyObject *obj;
12478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12479 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12480 return SWIG_Py_Void();
12481 }
12482
12483 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12484 PyObject *resultobj = 0;
12485 wxPyFileSystemHandler *result = 0 ;
12486
12487 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12491 wxPyEndAllowThreads(__tstate);
12492 if (PyErr_Occurred()) SWIG_fail;
12493 }
12494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12495 return resultobj;
12496 fail:
12497 return NULL;
12498 }
12499
12500
12501 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12502 PyObject *resultobj = 0;
12503 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12504 PyObject *arg2 = (PyObject *) 0 ;
12505 PyObject *arg3 = (PyObject *) 0 ;
12506 void *argp1 = 0 ;
12507 int res1 = 0 ;
12508 PyObject * obj0 = 0 ;
12509 PyObject * obj1 = 0 ;
12510 PyObject * obj2 = 0 ;
12511 char * kwnames[] = {
12512 (char *) "self",(char *) "self",(char *) "_class", NULL
12513 };
12514
12515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12517 if (!SWIG_IsOK(res1)) {
12518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12519 }
12520 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12521 arg2 = obj1;
12522 arg3 = obj2;
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 (arg1)->_setCallbackInfo(arg2,arg3);
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 resultobj = SWIG_Py_Void();
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj = 0;
12538 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12539 wxString *arg2 = 0 ;
12540 bool result;
12541 void *argp1 = 0 ;
12542 int res1 = 0 ;
12543 bool temp2 = false ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 char * kwnames[] = {
12547 (char *) "self",(char *) "location", NULL
12548 };
12549
12550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12552 if (!SWIG_IsOK(res1)) {
12553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12554 }
12555 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12556 {
12557 arg2 = wxString_in_helper(obj1);
12558 if (arg2 == NULL) SWIG_fail;
12559 temp2 = true;
12560 }
12561 {
12562 PyThreadState* __tstate = wxPyBeginAllowThreads();
12563 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12564 wxPyEndAllowThreads(__tstate);
12565 if (PyErr_Occurred()) SWIG_fail;
12566 }
12567 {
12568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12569 }
12570 {
12571 if (temp2)
12572 delete arg2;
12573 }
12574 return resultobj;
12575 fail:
12576 {
12577 if (temp2)
12578 delete arg2;
12579 }
12580 return NULL;
12581 }
12582
12583
12584 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12585 PyObject *resultobj = 0;
12586 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12587 wxFileSystem *arg2 = 0 ;
12588 wxString *arg3 = 0 ;
12589 wxFSFile *result = 0 ;
12590 void *argp1 = 0 ;
12591 int res1 = 0 ;
12592 void *argp2 = 0 ;
12593 int res2 = 0 ;
12594 bool temp3 = false ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 PyObject * obj2 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "self",(char *) "fs",(char *) "location", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12606 }
12607 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12609 if (!SWIG_IsOK(res2)) {
12610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12611 }
12612 if (!argp2) {
12613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12614 }
12615 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12616 {
12617 arg3 = wxString_in_helper(obj2);
12618 if (arg3 == NULL) SWIG_fail;
12619 temp3 = true;
12620 }
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12624 wxPyEndAllowThreads(__tstate);
12625 if (PyErr_Occurred()) SWIG_fail;
12626 }
12627 {
12628 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12629 }
12630 {
12631 if (temp3)
12632 delete arg3;
12633 }
12634 return resultobj;
12635 fail:
12636 {
12637 if (temp3)
12638 delete arg3;
12639 }
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = 0;
12646 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12647 wxString *arg2 = 0 ;
12648 int arg3 = (int) 0 ;
12649 wxString result;
12650 void *argp1 = 0 ;
12651 int res1 = 0 ;
12652 bool temp2 = false ;
12653 int val3 ;
12654 int ecode3 = 0 ;
12655 PyObject * obj0 = 0 ;
12656 PyObject * obj1 = 0 ;
12657 PyObject * obj2 = 0 ;
12658 char * kwnames[] = {
12659 (char *) "self",(char *) "spec",(char *) "flags", NULL
12660 };
12661
12662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12664 if (!SWIG_IsOK(res1)) {
12665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12666 }
12667 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12668 {
12669 arg2 = wxString_in_helper(obj1);
12670 if (arg2 == NULL) SWIG_fail;
12671 temp2 = true;
12672 }
12673 if (obj2) {
12674 ecode3 = SWIG_AsVal_int(obj2, &val3);
12675 if (!SWIG_IsOK(ecode3)) {
12676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12677 }
12678 arg3 = static_cast< int >(val3);
12679 }
12680 {
12681 PyThreadState* __tstate = wxPyBeginAllowThreads();
12682 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 #if wxUSE_UNICODE
12688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12689 #else
12690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12691 #endif
12692 }
12693 {
12694 if (temp2)
12695 delete arg2;
12696 }
12697 return resultobj;
12698 fail:
12699 {
12700 if (temp2)
12701 delete arg2;
12702 }
12703 return NULL;
12704 }
12705
12706
12707 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12708 PyObject *resultobj = 0;
12709 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12710 wxString result;
12711 void *argp1 = 0 ;
12712 int res1 = 0 ;
12713 PyObject *swig_obj[1] ;
12714
12715 if (!args) SWIG_fail;
12716 swig_obj[0] = args;
12717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12720 }
12721 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (arg1)->FindNext();
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 {
12729 #if wxUSE_UNICODE
12730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12731 #else
12732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12733 #endif
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj = 0;
12743 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12744 wxString *arg2 = 0 ;
12745 wxString result;
12746 void *argp1 = 0 ;
12747 int res1 = 0 ;
12748 bool temp2 = false ;
12749 PyObject * obj0 = 0 ;
12750 PyObject * obj1 = 0 ;
12751 char * kwnames[] = {
12752 (char *) "self",(char *) "location", NULL
12753 };
12754
12755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12757 if (!SWIG_IsOK(res1)) {
12758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12759 }
12760 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12761 {
12762 arg2 = wxString_in_helper(obj1);
12763 if (arg2 == NULL) SWIG_fail;
12764 temp2 = true;
12765 }
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (arg1)->GetProtocol((wxString const &)*arg2);
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 {
12773 #if wxUSE_UNICODE
12774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12775 #else
12776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12777 #endif
12778 }
12779 {
12780 if (temp2)
12781 delete arg2;
12782 }
12783 return resultobj;
12784 fail:
12785 {
12786 if (temp2)
12787 delete arg2;
12788 }
12789 return NULL;
12790 }
12791
12792
12793 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12794 PyObject *resultobj = 0;
12795 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12796 wxString *arg2 = 0 ;
12797 wxString result;
12798 void *argp1 = 0 ;
12799 int res1 = 0 ;
12800 bool temp2 = false ;
12801 PyObject * obj0 = 0 ;
12802 PyObject * obj1 = 0 ;
12803 char * kwnames[] = {
12804 (char *) "self",(char *) "location", NULL
12805 };
12806
12807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12809 if (!SWIG_IsOK(res1)) {
12810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12811 }
12812 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12813 {
12814 arg2 = wxString_in_helper(obj1);
12815 if (arg2 == NULL) SWIG_fail;
12816 temp2 = true;
12817 }
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 {
12825 #if wxUSE_UNICODE
12826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12827 #else
12828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12829 #endif
12830 }
12831 {
12832 if (temp2)
12833 delete arg2;
12834 }
12835 return resultobj;
12836 fail:
12837 {
12838 if (temp2)
12839 delete arg2;
12840 }
12841 return NULL;
12842 }
12843
12844
12845 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12846 PyObject *resultobj = 0;
12847 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12848 wxString *arg2 = 0 ;
12849 wxString result;
12850 void *argp1 = 0 ;
12851 int res1 = 0 ;
12852 bool temp2 = false ;
12853 PyObject * obj0 = 0 ;
12854 PyObject * obj1 = 0 ;
12855 char * kwnames[] = {
12856 (char *) "self",(char *) "location", NULL
12857 };
12858
12859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12861 if (!SWIG_IsOK(res1)) {
12862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12863 }
12864 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12865 {
12866 arg2 = wxString_in_helper(obj1);
12867 if (arg2 == NULL) SWIG_fail;
12868 temp2 = true;
12869 }
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 result = (arg1)->GetAnchor((wxString const &)*arg2);
12873 wxPyEndAllowThreads(__tstate);
12874 if (PyErr_Occurred()) SWIG_fail;
12875 }
12876 {
12877 #if wxUSE_UNICODE
12878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12879 #else
12880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12881 #endif
12882 }
12883 {
12884 if (temp2)
12885 delete arg2;
12886 }
12887 return resultobj;
12888 fail:
12889 {
12890 if (temp2)
12891 delete arg2;
12892 }
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12898 PyObject *resultobj = 0;
12899 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12900 wxString *arg2 = 0 ;
12901 wxString result;
12902 void *argp1 = 0 ;
12903 int res1 = 0 ;
12904 bool temp2 = false ;
12905 PyObject * obj0 = 0 ;
12906 PyObject * obj1 = 0 ;
12907 char * kwnames[] = {
12908 (char *) "self",(char *) "location", NULL
12909 };
12910
12911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12913 if (!SWIG_IsOK(res1)) {
12914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12915 }
12916 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12917 {
12918 arg2 = wxString_in_helper(obj1);
12919 if (arg2 == NULL) SWIG_fail;
12920 temp2 = true;
12921 }
12922 {
12923 PyThreadState* __tstate = wxPyBeginAllowThreads();
12924 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 {
12929 #if wxUSE_UNICODE
12930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12931 #else
12932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12933 #endif
12934 }
12935 {
12936 if (temp2)
12937 delete arg2;
12938 }
12939 return resultobj;
12940 fail:
12941 {
12942 if (temp2)
12943 delete arg2;
12944 }
12945 return NULL;
12946 }
12947
12948
12949 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj = 0;
12951 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12952 wxString *arg2 = 0 ;
12953 wxString result;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 bool temp2 = false ;
12957 PyObject * obj0 = 0 ;
12958 PyObject * obj1 = 0 ;
12959 char * kwnames[] = {
12960 (char *) "self",(char *) "location", NULL
12961 };
12962
12963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12965 if (!SWIG_IsOK(res1)) {
12966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12967 }
12968 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12969 {
12970 arg2 = wxString_in_helper(obj1);
12971 if (arg2 == NULL) SWIG_fail;
12972 temp2 = true;
12973 }
12974 {
12975 PyThreadState* __tstate = wxPyBeginAllowThreads();
12976 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12977 wxPyEndAllowThreads(__tstate);
12978 if (PyErr_Occurred()) SWIG_fail;
12979 }
12980 {
12981 #if wxUSE_UNICODE
12982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12983 #else
12984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12985 #endif
12986 }
12987 {
12988 if (temp2)
12989 delete arg2;
12990 }
12991 return resultobj;
12992 fail:
12993 {
12994 if (temp2)
12995 delete arg2;
12996 }
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *obj;
13003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13004 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13005 return SWIG_Py_Void();
13006 }
13007
13008 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13009 return SWIG_Python_InitShadowInstance(args);
13010 }
13011
13012 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13013 PyObject *resultobj = 0;
13014 wxFileSystem *result = 0 ;
13015
13016 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (wxFileSystem *)new wxFileSystem();
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13033 void *argp1 = 0 ;
13034 int res1 = 0 ;
13035 PyObject *swig_obj[1] ;
13036
13037 if (!args) SWIG_fail;
13038 swig_obj[0] = args;
13039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13040 if (!SWIG_IsOK(res1)) {
13041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13042 }
13043 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 delete arg1;
13047
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 resultobj = SWIG_Py_Void();
13052 return resultobj;
13053 fail:
13054 return NULL;
13055 }
13056
13057
13058 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13059 PyObject *resultobj = 0;
13060 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13061 wxString *arg2 = 0 ;
13062 bool arg3 = (bool) false ;
13063 void *argp1 = 0 ;
13064 int res1 = 0 ;
13065 bool temp2 = false ;
13066 bool val3 ;
13067 int ecode3 = 0 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 PyObject * obj2 = 0 ;
13071 char * kwnames[] = {
13072 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13073 };
13074
13075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13077 if (!SWIG_IsOK(res1)) {
13078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13079 }
13080 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13081 {
13082 arg2 = wxString_in_helper(obj1);
13083 if (arg2 == NULL) SWIG_fail;
13084 temp2 = true;
13085 }
13086 if (obj2) {
13087 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13088 if (!SWIG_IsOK(ecode3)) {
13089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13090 }
13091 arg3 = static_cast< bool >(val3);
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13096 wxPyEndAllowThreads(__tstate);
13097 if (PyErr_Occurred()) SWIG_fail;
13098 }
13099 resultobj = SWIG_Py_Void();
13100 {
13101 if (temp2)
13102 delete arg2;
13103 }
13104 return resultobj;
13105 fail:
13106 {
13107 if (temp2)
13108 delete arg2;
13109 }
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 PyObject *resultobj = 0;
13116 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13117 wxString result;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 PyObject *swig_obj[1] ;
13121
13122 if (!args) SWIG_fail;
13123 swig_obj[0] = args;
13124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13127 }
13128 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (arg1)->GetPath();
13132 wxPyEndAllowThreads(__tstate);
13133 if (PyErr_Occurred()) SWIG_fail;
13134 }
13135 {
13136 #if wxUSE_UNICODE
13137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13138 #else
13139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13140 #endif
13141 }
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj = 0;
13150 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13151 wxString *arg2 = 0 ;
13152 wxFSFile *result = 0 ;
13153 void *argp1 = 0 ;
13154 int res1 = 0 ;
13155 bool temp2 = false ;
13156 PyObject * obj0 = 0 ;
13157 PyObject * obj1 = 0 ;
13158 char * kwnames[] = {
13159 (char *) "self",(char *) "location", NULL
13160 };
13161
13162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13164 if (!SWIG_IsOK(res1)) {
13165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13166 }
13167 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13168 {
13169 arg2 = wxString_in_helper(obj1);
13170 if (arg2 == NULL) SWIG_fail;
13171 temp2 = true;
13172 }
13173 {
13174 PyThreadState* __tstate = wxPyBeginAllowThreads();
13175 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 {
13180 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13181 }
13182 {
13183 if (temp2)
13184 delete arg2;
13185 }
13186 return resultobj;
13187 fail:
13188 {
13189 if (temp2)
13190 delete arg2;
13191 }
13192 return NULL;
13193 }
13194
13195
13196 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj = 0;
13198 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13199 wxString *arg2 = 0 ;
13200 int arg3 = (int) 0 ;
13201 wxString result;
13202 void *argp1 = 0 ;
13203 int res1 = 0 ;
13204 bool temp2 = false ;
13205 int val3 ;
13206 int ecode3 = 0 ;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 PyObject * obj2 = 0 ;
13210 char * kwnames[] = {
13211 (char *) "self",(char *) "spec",(char *) "flags", NULL
13212 };
13213
13214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13216 if (!SWIG_IsOK(res1)) {
13217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13218 }
13219 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13220 {
13221 arg2 = wxString_in_helper(obj1);
13222 if (arg2 == NULL) SWIG_fail;
13223 temp2 = true;
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 '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13229 }
13230 arg3 = static_cast< int >(val3);
13231 }
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 {
13239 #if wxUSE_UNICODE
13240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13241 #else
13242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13243 #endif
13244 }
13245 {
13246 if (temp2)
13247 delete arg2;
13248 }
13249 return resultobj;
13250 fail:
13251 {
13252 if (temp2)
13253 delete arg2;
13254 }
13255 return NULL;
13256 }
13257
13258
13259 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13260 PyObject *resultobj = 0;
13261 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13262 wxString result;
13263 void *argp1 = 0 ;
13264 int res1 = 0 ;
13265 PyObject *swig_obj[1] ;
13266
13267 if (!args) SWIG_fail;
13268 swig_obj[0] = args;
13269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13270 if (!SWIG_IsOK(res1)) {
13271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13272 }
13273 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13274 {
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 result = (arg1)->FindNext();
13277 wxPyEndAllowThreads(__tstate);
13278 if (PyErr_Occurred()) SWIG_fail;
13279 }
13280 {
13281 #if wxUSE_UNICODE
13282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13283 #else
13284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13285 #endif
13286 }
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj = 0;
13295 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13296 int res1 = 0 ;
13297 PyObject * obj0 = 0 ;
13298 char * kwnames[] = {
13299 (char *) "handler", NULL
13300 };
13301
13302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13303 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13304 if (!SWIG_IsOK(res1)) {
13305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 wxFileSystem::AddHandler(arg1);
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 resultobj = SWIG_Py_Void();
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj = 0;
13322 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13323 wxFileSystemHandler *result = 0 ;
13324 void *argp1 = 0 ;
13325 int res1 = 0 ;
13326 PyObject * obj0 = 0 ;
13327 char * kwnames[] = {
13328 (char *) "handler", NULL
13329 };
13330
13331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13333 if (!SWIG_IsOK(res1)) {
13334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13335 }
13336 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13351 PyObject *resultobj = 0;
13352
13353 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 wxFileSystem::CleanUpHandlers();
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 resultobj = SWIG_Py_Void();
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13368 PyObject *resultobj = 0;
13369 wxString *arg1 = 0 ;
13370 wxString result;
13371 bool temp1 = false ;
13372 PyObject * obj0 = 0 ;
13373 char * kwnames[] = {
13374 (char *) "filename", NULL
13375 };
13376
13377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13378 {
13379 arg1 = wxString_in_helper(obj0);
13380 if (arg1 == NULL) SWIG_fail;
13381 temp1 = true;
13382 }
13383 {
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13386 wxPyEndAllowThreads(__tstate);
13387 if (PyErr_Occurred()) SWIG_fail;
13388 }
13389 {
13390 #if wxUSE_UNICODE
13391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13392 #else
13393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13394 #endif
13395 }
13396 {
13397 if (temp1)
13398 delete arg1;
13399 }
13400 return resultobj;
13401 fail:
13402 {
13403 if (temp1)
13404 delete arg1;
13405 }
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj = 0;
13412 wxString *arg1 = 0 ;
13413 wxString result;
13414 bool temp1 = false ;
13415 PyObject * obj0 = 0 ;
13416 char * kwnames[] = {
13417 (char *) "url", NULL
13418 };
13419
13420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13421 {
13422 arg1 = wxString_in_helper(obj0);
13423 if (arg1 == NULL) SWIG_fail;
13424 temp1 = true;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13437 #endif
13438 }
13439 {
13440 if (temp1)
13441 delete arg1;
13442 }
13443 return resultobj;
13444 fail:
13445 {
13446 if (temp1)
13447 delete arg1;
13448 }
13449 return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454 PyObject *obj;
13455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13456 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13457 return SWIG_Py_Void();
13458 }
13459
13460 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13461 return SWIG_Python_InitShadowInstance(args);
13462 }
13463
13464 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13465 PyObject *resultobj = 0;
13466 wxInternetFSHandler *result = 0 ;
13467
13468 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13469 {
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13472 wxPyEndAllowThreads(__tstate);
13473 if (PyErr_Occurred()) SWIG_fail;
13474 }
13475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj = 0;
13484 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13485 wxString *arg2 = 0 ;
13486 bool result;
13487 void *argp1 = 0 ;
13488 int res1 = 0 ;
13489 bool temp2 = false ;
13490 PyObject * obj0 = 0 ;
13491 PyObject * obj1 = 0 ;
13492 char * kwnames[] = {
13493 (char *) "self",(char *) "location", NULL
13494 };
13495
13496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13500 }
13501 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13502 {
13503 arg2 = wxString_in_helper(obj1);
13504 if (arg2 == NULL) SWIG_fail;
13505 temp2 = true;
13506 }
13507 {
13508 PyThreadState* __tstate = wxPyBeginAllowThreads();
13509 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13510 wxPyEndAllowThreads(__tstate);
13511 if (PyErr_Occurred()) SWIG_fail;
13512 }
13513 {
13514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13515 }
13516 {
13517 if (temp2)
13518 delete arg2;
13519 }
13520 return resultobj;
13521 fail:
13522 {
13523 if (temp2)
13524 delete arg2;
13525 }
13526 return NULL;
13527 }
13528
13529
13530 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj = 0;
13532 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13533 wxFileSystem *arg2 = 0 ;
13534 wxString *arg3 = 0 ;
13535 wxFSFile *result = 0 ;
13536 void *argp1 = 0 ;
13537 int res1 = 0 ;
13538 void *argp2 = 0 ;
13539 int res2 = 0 ;
13540 bool temp3 = false ;
13541 PyObject * obj0 = 0 ;
13542 PyObject * obj1 = 0 ;
13543 PyObject * obj2 = 0 ;
13544 char * kwnames[] = {
13545 (char *) "self",(char *) "fs",(char *) "location", NULL
13546 };
13547
13548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13550 if (!SWIG_IsOK(res1)) {
13551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13552 }
13553 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13554 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13555 if (!SWIG_IsOK(res2)) {
13556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13557 }
13558 if (!argp2) {
13559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13560 }
13561 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13562 {
13563 arg3 = wxString_in_helper(obj2);
13564 if (arg3 == NULL) SWIG_fail;
13565 temp3 = true;
13566 }
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 {
13574 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13575 }
13576 {
13577 if (temp3)
13578 delete arg3;
13579 }
13580 return resultobj;
13581 fail:
13582 {
13583 if (temp3)
13584 delete arg3;
13585 }
13586 return NULL;
13587 }
13588
13589
13590 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13591 PyObject *obj;
13592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13593 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13594 return SWIG_Py_Void();
13595 }
13596
13597 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13598 return SWIG_Python_InitShadowInstance(args);
13599 }
13600
13601 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13602 PyObject *resultobj = 0;
13603 wxZipFSHandler *result = 0 ;
13604
13605 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 result = (wxZipFSHandler *)new wxZipFSHandler();
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj = 0;
13621 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13622 wxString *arg2 = 0 ;
13623 bool result;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 bool temp2 = false ;
13627 PyObject * obj0 = 0 ;
13628 PyObject * obj1 = 0 ;
13629 char * kwnames[] = {
13630 (char *) "self",(char *) "location", NULL
13631 };
13632
13633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13635 if (!SWIG_IsOK(res1)) {
13636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13637 }
13638 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13639 {
13640 arg2 = wxString_in_helper(obj1);
13641 if (arg2 == NULL) SWIG_fail;
13642 temp2 = true;
13643 }
13644 {
13645 PyThreadState* __tstate = wxPyBeginAllowThreads();
13646 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 {
13651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13652 }
13653 {
13654 if (temp2)
13655 delete arg2;
13656 }
13657 return resultobj;
13658 fail:
13659 {
13660 if (temp2)
13661 delete arg2;
13662 }
13663 return NULL;
13664 }
13665
13666
13667 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = 0;
13669 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13670 wxFileSystem *arg2 = 0 ;
13671 wxString *arg3 = 0 ;
13672 wxFSFile *result = 0 ;
13673 void *argp1 = 0 ;
13674 int res1 = 0 ;
13675 void *argp2 = 0 ;
13676 int res2 = 0 ;
13677 bool temp3 = false ;
13678 PyObject * obj0 = 0 ;
13679 PyObject * obj1 = 0 ;
13680 PyObject * obj2 = 0 ;
13681 char * kwnames[] = {
13682 (char *) "self",(char *) "fs",(char *) "location", NULL
13683 };
13684
13685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13687 if (!SWIG_IsOK(res1)) {
13688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13689 }
13690 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13692 if (!SWIG_IsOK(res2)) {
13693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13694 }
13695 if (!argp2) {
13696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13697 }
13698 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13699 {
13700 arg3 = wxString_in_helper(obj2);
13701 if (arg3 == NULL) SWIG_fail;
13702 temp3 = true;
13703 }
13704 {
13705 PyThreadState* __tstate = wxPyBeginAllowThreads();
13706 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13707 wxPyEndAllowThreads(__tstate);
13708 if (PyErr_Occurred()) SWIG_fail;
13709 }
13710 {
13711 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13712 }
13713 {
13714 if (temp3)
13715 delete arg3;
13716 }
13717 return resultobj;
13718 fail:
13719 {
13720 if (temp3)
13721 delete arg3;
13722 }
13723 return NULL;
13724 }
13725
13726
13727 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj = 0;
13729 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13730 wxString *arg2 = 0 ;
13731 int arg3 = (int) 0 ;
13732 wxString result;
13733 void *argp1 = 0 ;
13734 int res1 = 0 ;
13735 bool temp2 = false ;
13736 int val3 ;
13737 int ecode3 = 0 ;
13738 PyObject * obj0 = 0 ;
13739 PyObject * obj1 = 0 ;
13740 PyObject * obj2 = 0 ;
13741 char * kwnames[] = {
13742 (char *) "self",(char *) "spec",(char *) "flags", NULL
13743 };
13744
13745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13747 if (!SWIG_IsOK(res1)) {
13748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13749 }
13750 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13751 {
13752 arg2 = wxString_in_helper(obj1);
13753 if (arg2 == NULL) SWIG_fail;
13754 temp2 = true;
13755 }
13756 if (obj2) {
13757 ecode3 = SWIG_AsVal_int(obj2, &val3);
13758 if (!SWIG_IsOK(ecode3)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13760 }
13761 arg3 = static_cast< int >(val3);
13762 }
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 {
13770 #if wxUSE_UNICODE
13771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13772 #else
13773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13774 #endif
13775 }
13776 {
13777 if (temp2)
13778 delete arg2;
13779 }
13780 return resultobj;
13781 fail:
13782 {
13783 if (temp2)
13784 delete arg2;
13785 }
13786 return NULL;
13787 }
13788
13789
13790 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13791 PyObject *resultobj = 0;
13792 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13793 wxString result;
13794 void *argp1 = 0 ;
13795 int res1 = 0 ;
13796 PyObject *swig_obj[1] ;
13797
13798 if (!args) SWIG_fail;
13799 swig_obj[0] = args;
13800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13801 if (!SWIG_IsOK(res1)) {
13802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13803 }
13804 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13805 {
13806 PyThreadState* __tstate = wxPyBeginAllowThreads();
13807 result = (arg1)->FindNext();
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 {
13812 #if wxUSE_UNICODE
13813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13814 #else
13815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13816 #endif
13817 }
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13825 PyObject *obj;
13826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13827 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13828 return SWIG_Py_Void();
13829 }
13830
13831 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13832 return SWIG_Python_InitShadowInstance(args);
13833 }
13834
13835 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13836 PyObject *resultobj = 0;
13837 wxString *arg1 = 0 ;
13838 wxImage *arg2 = 0 ;
13839 long arg3 ;
13840 bool temp1 = false ;
13841 void *argp2 = 0 ;
13842 int res2 = 0 ;
13843 long val3 ;
13844 int ecode3 = 0 ;
13845 PyObject * obj0 = 0 ;
13846 PyObject * obj1 = 0 ;
13847 PyObject * obj2 = 0 ;
13848 char * kwnames[] = {
13849 (char *) "filename",(char *) "image",(char *) "type", NULL
13850 };
13851
13852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13853 {
13854 arg1 = wxString_in_helper(obj0);
13855 if (arg1 == NULL) SWIG_fail;
13856 temp1 = true;
13857 }
13858 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13859 if (!SWIG_IsOK(res2)) {
13860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13861 }
13862 if (!argp2) {
13863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13864 }
13865 arg2 = reinterpret_cast< wxImage * >(argp2);
13866 ecode3 = SWIG_AsVal_long(obj2, &val3);
13867 if (!SWIG_IsOK(ecode3)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13869 }
13870 arg3 = static_cast< long >(val3);
13871 {
13872 PyThreadState* __tstate = wxPyBeginAllowThreads();
13873 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_Py_Void();
13878 {
13879 if (temp1)
13880 delete arg1;
13881 }
13882 return resultobj;
13883 fail:
13884 {
13885 if (temp1)
13886 delete arg1;
13887 }
13888 return NULL;
13889 }
13890
13891
13892 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj = 0;
13894 wxString *arg1 = 0 ;
13895 wxBitmap *arg2 = 0 ;
13896 long arg3 ;
13897 bool temp1 = false ;
13898 void *argp2 = 0 ;
13899 int res2 = 0 ;
13900 long val3 ;
13901 int ecode3 = 0 ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13910 {
13911 arg1 = wxString_in_helper(obj0);
13912 if (arg1 == NULL) SWIG_fail;
13913 temp1 = true;
13914 }
13915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13916 if (!SWIG_IsOK(res2)) {
13917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13918 }
13919 if (!argp2) {
13920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13921 }
13922 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13923 ecode3 = SWIG_AsVal_long(obj2, &val3);
13924 if (!SWIG_IsOK(ecode3)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13926 }
13927 arg3 = static_cast< long >(val3);
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 resultobj = SWIG_Py_Void();
13935 {
13936 if (temp1)
13937 delete arg1;
13938 }
13939 return resultobj;
13940 fail:
13941 {
13942 if (temp1)
13943 delete arg1;
13944 }
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj = 0;
13951 wxString *arg1 = 0 ;
13952 PyObject *arg2 = (PyObject *) 0 ;
13953 bool temp1 = false ;
13954 PyObject * obj0 = 0 ;
13955 PyObject * obj1 = 0 ;
13956 char * kwnames[] = {
13957 (char *) "filename",(char *) "data", NULL
13958 };
13959
13960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13961 {
13962 arg1 = wxString_in_helper(obj0);
13963 if (arg1 == NULL) SWIG_fail;
13964 temp1 = true;
13965 }
13966 arg2 = obj1;
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 resultobj = SWIG_Py_Void();
13974 {
13975 if (temp1)
13976 delete arg1;
13977 }
13978 return resultobj;
13979 fail:
13980 {
13981 if (temp1)
13982 delete arg1;
13983 }
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13989 PyObject *resultobj = 0;
13990 wxMemoryFSHandler *result = 0 ;
13991
13992 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14000 return resultobj;
14001 fail:
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14007 PyObject *resultobj = 0;
14008 wxString *arg1 = 0 ;
14009 bool temp1 = false ;
14010 PyObject * obj0 = 0 ;
14011 char * kwnames[] = {
14012 (char *) "filename", NULL
14013 };
14014
14015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14016 {
14017 arg1 = wxString_in_helper(obj0);
14018 if (arg1 == NULL) SWIG_fail;
14019 temp1 = true;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_Py_Void();
14028 {
14029 if (temp1)
14030 delete arg1;
14031 }
14032 return resultobj;
14033 fail:
14034 {
14035 if (temp1)
14036 delete arg1;
14037 }
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14043 PyObject *resultobj = 0;
14044 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14045 wxString *arg2 = 0 ;
14046 bool result;
14047 void *argp1 = 0 ;
14048 int res1 = 0 ;
14049 bool temp2 = false ;
14050 PyObject * obj0 = 0 ;
14051 PyObject * obj1 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "self",(char *) "location", NULL
14054 };
14055
14056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14060 }
14061 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14062 {
14063 arg2 = wxString_in_helper(obj1);
14064 if (arg2 == NULL) SWIG_fail;
14065 temp2 = true;
14066 }
14067 {
14068 PyThreadState* __tstate = wxPyBeginAllowThreads();
14069 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14070 wxPyEndAllowThreads(__tstate);
14071 if (PyErr_Occurred()) SWIG_fail;
14072 }
14073 {
14074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14075 }
14076 {
14077 if (temp2)
14078 delete arg2;
14079 }
14080 return resultobj;
14081 fail:
14082 {
14083 if (temp2)
14084 delete arg2;
14085 }
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14093 wxFileSystem *arg2 = 0 ;
14094 wxString *arg3 = 0 ;
14095 wxFSFile *result = 0 ;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 void *argp2 = 0 ;
14099 int res2 = 0 ;
14100 bool temp3 = false ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "fs",(char *) "location", NULL
14106 };
14107
14108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14112 }
14113 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14115 if (!SWIG_IsOK(res2)) {
14116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14117 }
14118 if (!argp2) {
14119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14120 }
14121 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14122 {
14123 arg3 = wxString_in_helper(obj2);
14124 if (arg3 == NULL) SWIG_fail;
14125 temp3 = true;
14126 }
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14135 }
14136 {
14137 if (temp3)
14138 delete arg3;
14139 }
14140 return resultobj;
14141 fail:
14142 {
14143 if (temp3)
14144 delete arg3;
14145 }
14146 return NULL;
14147 }
14148
14149
14150 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = 0;
14152 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14153 wxString *arg2 = 0 ;
14154 int arg3 = (int) 0 ;
14155 wxString result;
14156 void *argp1 = 0 ;
14157 int res1 = 0 ;
14158 bool temp2 = false ;
14159 int val3 ;
14160 int ecode3 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 PyObject * obj1 = 0 ;
14163 PyObject * obj2 = 0 ;
14164 char * kwnames[] = {
14165 (char *) "self",(char *) "spec",(char *) "flags", NULL
14166 };
14167
14168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14172 }
14173 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14174 {
14175 arg2 = wxString_in_helper(obj1);
14176 if (arg2 == NULL) SWIG_fail;
14177 temp2 = true;
14178 }
14179 if (obj2) {
14180 ecode3 = SWIG_AsVal_int(obj2, &val3);
14181 if (!SWIG_IsOK(ecode3)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14183 }
14184 arg3 = static_cast< int >(val3);
14185 }
14186 {
14187 PyThreadState* __tstate = wxPyBeginAllowThreads();
14188 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14189 wxPyEndAllowThreads(__tstate);
14190 if (PyErr_Occurred()) SWIG_fail;
14191 }
14192 {
14193 #if wxUSE_UNICODE
14194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14195 #else
14196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14197 #endif
14198 }
14199 {
14200 if (temp2)
14201 delete arg2;
14202 }
14203 return resultobj;
14204 fail:
14205 {
14206 if (temp2)
14207 delete arg2;
14208 }
14209 return NULL;
14210 }
14211
14212
14213 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14214 PyObject *resultobj = 0;
14215 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14216 wxString result;
14217 void *argp1 = 0 ;
14218 int res1 = 0 ;
14219 PyObject *swig_obj[1] ;
14220
14221 if (!args) SWIG_fail;
14222 swig_obj[0] = args;
14223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14224 if (!SWIG_IsOK(res1)) {
14225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14226 }
14227 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (arg1)->FindNext();
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 {
14235 #if wxUSE_UNICODE
14236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14237 #else
14238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14239 #endif
14240 }
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14248 PyObject *obj;
14249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14250 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14251 return SWIG_Py_Void();
14252 }
14253
14254 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14255 return SWIG_Python_InitShadowInstance(args);
14256 }
14257
14258 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14259 PyObject *resultobj = 0;
14260 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14261 wxString result;
14262 void *argp1 = 0 ;
14263 int res1 = 0 ;
14264 PyObject *swig_obj[1] ;
14265
14266 if (!args) SWIG_fail;
14267 swig_obj[0] = args;
14268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14269 if (!SWIG_IsOK(res1)) {
14270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14271 }
14272 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14273 {
14274 PyThreadState* __tstate = wxPyBeginAllowThreads();
14275 result = (arg1)->GetName();
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 {
14280 #if wxUSE_UNICODE
14281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14282 #else
14283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14284 #endif
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14293 PyObject *resultobj = 0;
14294 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14295 wxString result;
14296 void *argp1 = 0 ;
14297 int res1 = 0 ;
14298 PyObject *swig_obj[1] ;
14299
14300 if (!args) SWIG_fail;
14301 swig_obj[0] = args;
14302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14303 if (!SWIG_IsOK(res1)) {
14304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14305 }
14306 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (arg1)->GetExtension();
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 {
14314 #if wxUSE_UNICODE
14315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14316 #else
14317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14318 #endif
14319 }
14320 return resultobj;
14321 fail:
14322 return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14327 PyObject *resultobj = 0;
14328 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14329 long result;
14330 void *argp1 = 0 ;
14331 int res1 = 0 ;
14332 PyObject *swig_obj[1] ;
14333
14334 if (!args) SWIG_fail;
14335 swig_obj[0] = args;
14336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14337 if (!SWIG_IsOK(res1)) {
14338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14339 }
14340 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14341 {
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 result = (long)(arg1)->GetType();
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 resultobj = SWIG_From_long(static_cast< long >(result));
14348 return resultobj;
14349 fail:
14350 return NULL;
14351 }
14352
14353
14354 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14355 PyObject *resultobj = 0;
14356 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14357 wxString result;
14358 void *argp1 = 0 ;
14359 int res1 = 0 ;
14360 PyObject *swig_obj[1] ;
14361
14362 if (!args) SWIG_fail;
14363 swig_obj[0] = args;
14364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14365 if (!SWIG_IsOK(res1)) {
14366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14367 }
14368 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (arg1)->GetMimeType();
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 {
14376 #if wxUSE_UNICODE
14377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14378 #else
14379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14380 #endif
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj = 0;
14390 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14391 wxString *arg2 = 0 ;
14392 bool result;
14393 void *argp1 = 0 ;
14394 int res1 = 0 ;
14395 bool temp2 = false ;
14396 PyObject * obj0 = 0 ;
14397 PyObject * obj1 = 0 ;
14398 char * kwnames[] = {
14399 (char *) "self",(char *) "name", NULL
14400 };
14401
14402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14404 if (!SWIG_IsOK(res1)) {
14405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14406 }
14407 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14408 {
14409 arg2 = wxString_in_helper(obj1);
14410 if (arg2 == NULL) SWIG_fail;
14411 temp2 = true;
14412 }
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 {
14420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14421 }
14422 {
14423 if (temp2)
14424 delete arg2;
14425 }
14426 return resultobj;
14427 fail:
14428 {
14429 if (temp2)
14430 delete arg2;
14431 }
14432 return NULL;
14433 }
14434
14435
14436 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14437 PyObject *resultobj = 0;
14438 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14439 wxInputStream *arg2 = 0 ;
14440 bool result;
14441 void *argp1 = 0 ;
14442 int res1 = 0 ;
14443 wxPyInputStream *temp2 ;
14444 bool created2 ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 char * kwnames[] = {
14448 (char *) "self",(char *) "stream", NULL
14449 };
14450
14451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14455 }
14456 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14457 {
14458 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14459 arg2 = temp2->m_wxis;
14460 created2 = false;
14461 } else {
14462 PyErr_Clear(); // clear the failure of the wxPyConvert above
14463 arg2 = wxPyCBInputStream_create(obj1, false);
14464 if (arg2 == NULL) {
14465 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14466 SWIG_fail;
14467 }
14468 created2 = true;
14469 }
14470 }
14471 {
14472 PyThreadState* __tstate = wxPyBeginAllowThreads();
14473 result = (bool)(arg1)->CanRead(*arg2);
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 {
14478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14479 }
14480 {
14481 if (created2) delete arg2;
14482 }
14483 return resultobj;
14484 fail:
14485 {
14486 if (created2) delete arg2;
14487 }
14488 return NULL;
14489 }
14490
14491
14492 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14493 PyObject *resultobj = 0;
14494 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14495 wxString *arg2 = 0 ;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 bool temp2 = false ;
14499 PyObject * obj0 = 0 ;
14500 PyObject * obj1 = 0 ;
14501 char * kwnames[] = {
14502 (char *) "self",(char *) "name", NULL
14503 };
14504
14505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14507 if (!SWIG_IsOK(res1)) {
14508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14509 }
14510 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14511 {
14512 arg2 = wxString_in_helper(obj1);
14513 if (arg2 == NULL) SWIG_fail;
14514 temp2 = true;
14515 }
14516 {
14517 PyThreadState* __tstate = wxPyBeginAllowThreads();
14518 (arg1)->SetName((wxString const &)*arg2);
14519 wxPyEndAllowThreads(__tstate);
14520 if (PyErr_Occurred()) SWIG_fail;
14521 }
14522 resultobj = SWIG_Py_Void();
14523 {
14524 if (temp2)
14525 delete arg2;
14526 }
14527 return resultobj;
14528 fail:
14529 {
14530 if (temp2)
14531 delete arg2;
14532 }
14533 return NULL;
14534 }
14535
14536
14537 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj = 0;
14539 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14540 wxString *arg2 = 0 ;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 bool temp2 = false ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 char * kwnames[] = {
14547 (char *) "self",(char *) "extension", NULL
14548 };
14549
14550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14554 }
14555 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14556 {
14557 arg2 = wxString_in_helper(obj1);
14558 if (arg2 == NULL) SWIG_fail;
14559 temp2 = true;
14560 }
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 (arg1)->SetExtension((wxString const &)*arg2);
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 resultobj = SWIG_Py_Void();
14568 {
14569 if (temp2)
14570 delete arg2;
14571 }
14572 return resultobj;
14573 fail:
14574 {
14575 if (temp2)
14576 delete arg2;
14577 }
14578 return NULL;
14579 }
14580
14581
14582 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj = 0;
14584 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14585 long arg2 ;
14586 void *argp1 = 0 ;
14587 int res1 = 0 ;
14588 long val2 ;
14589 int ecode2 = 0 ;
14590 PyObject * obj0 = 0 ;
14591 PyObject * obj1 = 0 ;
14592 char * kwnames[] = {
14593 (char *) "self",(char *) "type", NULL
14594 };
14595
14596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14598 if (!SWIG_IsOK(res1)) {
14599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14600 }
14601 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14602 ecode2 = SWIG_AsVal_long(obj1, &val2);
14603 if (!SWIG_IsOK(ecode2)) {
14604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14605 }
14606 arg2 = static_cast< long >(val2);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 (arg1)->SetType(arg2);
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 resultobj = SWIG_Py_Void();
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14621 PyObject *resultobj = 0;
14622 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14623 wxString *arg2 = 0 ;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 bool temp2 = false ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 char * kwnames[] = {
14630 (char *) "self",(char *) "mimetype", NULL
14631 };
14632
14633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14635 if (!SWIG_IsOK(res1)) {
14636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14637 }
14638 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 (arg1)->SetMimeType((wxString const &)*arg2);
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 resultobj = SWIG_Py_Void();
14651 {
14652 if (temp2)
14653 delete arg2;
14654 }
14655 return resultobj;
14656 fail:
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 return NULL;
14662 }
14663
14664
14665 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14666 PyObject *obj;
14667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14668 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14669 return SWIG_Py_Void();
14670 }
14671
14672 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14673 PyObject *resultobj = 0;
14674 wxPyImageHandler *result = 0 ;
14675
14676 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (wxPyImageHandler *)new wxPyImageHandler();
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj = 0;
14692 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14693 PyObject *arg2 = (PyObject *) 0 ;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 char * kwnames[] = {
14699 (char *) "self",(char *) "self", NULL
14700 };
14701
14702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14704 if (!SWIG_IsOK(res1)) {
14705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14706 }
14707 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14708 arg2 = obj1;
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 (arg1)->_SetSelf(arg2);
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 resultobj = SWIG_Py_Void();
14716 return resultobj;
14717 fail:
14718 return NULL;
14719 }
14720
14721
14722 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14723 PyObject *obj;
14724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14725 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14726 return SWIG_Py_Void();
14727 }
14728
14729 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 return SWIG_Python_InitShadowInstance(args);
14731 }
14732
14733 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14734 PyObject *resultobj = 0;
14735 wxImageHistogram *result = 0 ;
14736
14737 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (wxImageHistogram *)new wxImageHistogram();
14741 wxPyEndAllowThreads(__tstate);
14742 if (PyErr_Occurred()) SWIG_fail;
14743 }
14744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14745 return resultobj;
14746 fail:
14747 return NULL;
14748 }
14749
14750
14751 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14752 PyObject *resultobj = 0;
14753 byte arg1 ;
14754 byte arg2 ;
14755 byte arg3 ;
14756 unsigned long result;
14757 unsigned char val1 ;
14758 int ecode1 = 0 ;
14759 unsigned char val2 ;
14760 int ecode2 = 0 ;
14761 unsigned char val3 ;
14762 int ecode3 = 0 ;
14763 PyObject * obj0 = 0 ;
14764 PyObject * obj1 = 0 ;
14765 PyObject * obj2 = 0 ;
14766 char * kwnames[] = {
14767 (char *) "r",(char *) "g",(char *) "b", NULL
14768 };
14769
14770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14771 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14772 if (!SWIG_IsOK(ecode1)) {
14773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14774 }
14775 arg1 = static_cast< byte >(val1);
14776 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14777 if (!SWIG_IsOK(ecode2)) {
14778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14779 }
14780 arg2 = static_cast< byte >(val2);
14781 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14782 if (!SWIG_IsOK(ecode3)) {
14783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14784 }
14785 arg3 = static_cast< byte >(val3);
14786 {
14787 PyThreadState* __tstate = wxPyBeginAllowThreads();
14788 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14789 wxPyEndAllowThreads(__tstate);
14790 if (PyErr_Occurred()) SWIG_fail;
14791 }
14792 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14793 return resultobj;
14794 fail:
14795 return NULL;
14796 }
14797
14798
14799 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14800 PyObject *resultobj = 0;
14801 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14802 byte *arg2 = (byte *) 0 ;
14803 byte *arg3 = (byte *) 0 ;
14804 byte *arg4 = (byte *) 0 ;
14805 byte arg5 = (byte) 1 ;
14806 byte arg6 = (byte) 0 ;
14807 byte arg7 = (byte) 0 ;
14808 bool result;
14809 void *argp1 = 0 ;
14810 int res1 = 0 ;
14811 byte temp2 ;
14812 int res2 = SWIG_TMPOBJ ;
14813 byte temp3 ;
14814 int res3 = SWIG_TMPOBJ ;
14815 byte temp4 ;
14816 int res4 = SWIG_TMPOBJ ;
14817 unsigned char val5 ;
14818 int ecode5 = 0 ;
14819 unsigned char val6 ;
14820 int ecode6 = 0 ;
14821 unsigned char val7 ;
14822 int ecode7 = 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 PyObject * obj3 = 0 ;
14827 char * kwnames[] = {
14828 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14829 };
14830
14831 arg2 = &temp2;
14832 arg3 = &temp3;
14833 arg4 = &temp4;
14834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14838 }
14839 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14840 if (obj1) {
14841 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14842 if (!SWIG_IsOK(ecode5)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14844 }
14845 arg5 = static_cast< byte >(val5);
14846 }
14847 if (obj2) {
14848 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14849 if (!SWIG_IsOK(ecode6)) {
14850 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14851 }
14852 arg6 = static_cast< byte >(val6);
14853 }
14854 if (obj3) {
14855 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14856 if (!SWIG_IsOK(ecode7)) {
14857 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14858 }
14859 arg7 = static_cast< byte >(val7);
14860 }
14861 {
14862 PyThreadState* __tstate = wxPyBeginAllowThreads();
14863 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 {
14868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14869 }
14870 if (SWIG_IsTmpObj(res2)) {
14871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14872 } else {
14873 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14875 }
14876 if (SWIG_IsTmpObj(res3)) {
14877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14878 } else {
14879 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14881 }
14882 if (SWIG_IsTmpObj(res4)) {
14883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14884 } else {
14885 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14887 }
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj = 0;
14896 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14897 unsigned long arg2 ;
14898 unsigned long result;
14899 void *argp1 = 0 ;
14900 int res1 = 0 ;
14901 unsigned long val2 ;
14902 int ecode2 = 0 ;
14903 PyObject * obj0 = 0 ;
14904 PyObject * obj1 = 0 ;
14905 char * kwnames[] = {
14906 (char *) "self",(char *) "key", NULL
14907 };
14908
14909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14913 }
14914 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14915 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14916 if (!SWIG_IsOK(ecode2)) {
14917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14918 }
14919 arg2 = static_cast< unsigned long >(val2);
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj = 0;
14935 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14936 byte arg2 ;
14937 byte arg3 ;
14938 byte arg4 ;
14939 unsigned long result;
14940 void *argp1 = 0 ;
14941 int res1 = 0 ;
14942 unsigned char val2 ;
14943 int ecode2 = 0 ;
14944 unsigned char val3 ;
14945 int ecode3 = 0 ;
14946 unsigned char val4 ;
14947 int ecode4 = 0 ;
14948 PyObject * obj0 = 0 ;
14949 PyObject * obj1 = 0 ;
14950 PyObject * obj2 = 0 ;
14951 PyObject * obj3 = 0 ;
14952 char * kwnames[] = {
14953 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14954 };
14955
14956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14958 if (!SWIG_IsOK(res1)) {
14959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14960 }
14961 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14962 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14963 if (!SWIG_IsOK(ecode2)) {
14964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14965 }
14966 arg2 = static_cast< byte >(val2);
14967 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14968 if (!SWIG_IsOK(ecode3)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14970 }
14971 arg3 = static_cast< byte >(val3);
14972 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14973 if (!SWIG_IsOK(ecode4)) {
14974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14975 }
14976 arg4 = static_cast< byte >(val4);
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj = 0;
14992 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14993 wxColour *arg2 = 0 ;
14994 unsigned long result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 wxColour temp2 ;
14998 PyObject * obj0 = 0 ;
14999 PyObject * obj1 = 0 ;
15000 char * kwnames[] = {
15001 (char *) "self",(char *) "colour", NULL
15002 };
15003
15004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15006 if (!SWIG_IsOK(res1)) {
15007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15008 }
15009 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15010 {
15011 arg2 = &temp2;
15012 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15013 }
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15028 PyObject *obj;
15029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15030 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15031 return SWIG_Py_Void();
15032 }
15033
15034 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15035 return SWIG_Python_InitShadowInstance(args);
15036 }
15037
15038 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15039 PyObject *resultobj = 0;
15040 byte arg1 = (byte) 0 ;
15041 byte arg2 = (byte) 0 ;
15042 byte arg3 = (byte) 0 ;
15043 wxImage_RGBValue *result = 0 ;
15044 unsigned char val1 ;
15045 int ecode1 = 0 ;
15046 unsigned char val2 ;
15047 int ecode2 = 0 ;
15048 unsigned char val3 ;
15049 int ecode3 = 0 ;
15050 PyObject * obj0 = 0 ;
15051 PyObject * obj1 = 0 ;
15052 PyObject * obj2 = 0 ;
15053 char * kwnames[] = {
15054 (char *) "r",(char *) "g",(char *) "b", NULL
15055 };
15056
15057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15058 if (obj0) {
15059 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15060 if (!SWIG_IsOK(ecode1)) {
15061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15062 }
15063 arg1 = static_cast< byte >(val1);
15064 }
15065 if (obj1) {
15066 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15067 if (!SWIG_IsOK(ecode2)) {
15068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15069 }
15070 arg2 = static_cast< byte >(val2);
15071 }
15072 if (obj2) {
15073 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15074 if (!SWIG_IsOK(ecode3)) {
15075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15076 }
15077 arg3 = static_cast< byte >(val3);
15078 }
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15093 PyObject *resultobj = 0;
15094 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15095 byte arg2 ;
15096 void *argp1 = 0 ;
15097 int res1 = 0 ;
15098 unsigned char val2 ;
15099 int ecode2 = 0 ;
15100 PyObject *swig_obj[2] ;
15101
15102 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15104 if (!SWIG_IsOK(res1)) {
15105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15106 }
15107 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15108 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15109 if (!SWIG_IsOK(ecode2)) {
15110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15111 }
15112 arg2 = static_cast< byte >(val2);
15113 if (arg1) (arg1)->red = arg2;
15114
15115 resultobj = SWIG_Py_Void();
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15123 PyObject *resultobj = 0;
15124 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15125 byte result;
15126 void *argp1 = 0 ;
15127 int res1 = 0 ;
15128 PyObject *swig_obj[1] ;
15129
15130 if (!args) SWIG_fail;
15131 swig_obj[0] = args;
15132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15135 }
15136 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15137 result = (byte) ((arg1)->red);
15138 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15139 return resultobj;
15140 fail:
15141 return NULL;
15142 }
15143
15144
15145 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15146 PyObject *resultobj = 0;
15147 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15148 byte arg2 ;
15149 void *argp1 = 0 ;
15150 int res1 = 0 ;
15151 unsigned char val2 ;
15152 int ecode2 = 0 ;
15153 PyObject *swig_obj[2] ;
15154
15155 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15157 if (!SWIG_IsOK(res1)) {
15158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15159 }
15160 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15161 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15162 if (!SWIG_IsOK(ecode2)) {
15163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15164 }
15165 arg2 = static_cast< byte >(val2);
15166 if (arg1) (arg1)->green = arg2;
15167
15168 resultobj = SWIG_Py_Void();
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15176 PyObject *resultobj = 0;
15177 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15178 byte result;
15179 void *argp1 = 0 ;
15180 int res1 = 0 ;
15181 PyObject *swig_obj[1] ;
15182
15183 if (!args) SWIG_fail;
15184 swig_obj[0] = args;
15185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15186 if (!SWIG_IsOK(res1)) {
15187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15188 }
15189 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15190 result = (byte) ((arg1)->green);
15191 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15199 PyObject *resultobj = 0;
15200 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15201 byte arg2 ;
15202 void *argp1 = 0 ;
15203 int res1 = 0 ;
15204 unsigned char val2 ;
15205 int ecode2 = 0 ;
15206 PyObject *swig_obj[2] ;
15207
15208 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15210 if (!SWIG_IsOK(res1)) {
15211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15212 }
15213 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15214 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15215 if (!SWIG_IsOK(ecode2)) {
15216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15217 }
15218 arg2 = static_cast< byte >(val2);
15219 if (arg1) (arg1)->blue = arg2;
15220
15221 resultobj = SWIG_Py_Void();
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15229 PyObject *resultobj = 0;
15230 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15231 byte result;
15232 void *argp1 = 0 ;
15233 int res1 = 0 ;
15234 PyObject *swig_obj[1] ;
15235
15236 if (!args) SWIG_fail;
15237 swig_obj[0] = args;
15238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15239 if (!SWIG_IsOK(res1)) {
15240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15241 }
15242 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15243 result = (byte) ((arg1)->blue);
15244 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *obj;
15253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15254 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15255 return SWIG_Py_Void();
15256 }
15257
15258 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15259 return SWIG_Python_InitShadowInstance(args);
15260 }
15261
15262 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj = 0;
15264 double arg1 = (double) 0.0 ;
15265 double arg2 = (double) 0.0 ;
15266 double arg3 = (double) 0.0 ;
15267 wxImage_HSVValue *result = 0 ;
15268 double val1 ;
15269 int ecode1 = 0 ;
15270 double val2 ;
15271 int ecode2 = 0 ;
15272 double val3 ;
15273 int ecode3 = 0 ;
15274 PyObject * obj0 = 0 ;
15275 PyObject * obj1 = 0 ;
15276 PyObject * obj2 = 0 ;
15277 char * kwnames[] = {
15278 (char *) "h",(char *) "s",(char *) "v", NULL
15279 };
15280
15281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15282 if (obj0) {
15283 ecode1 = SWIG_AsVal_double(obj0, &val1);
15284 if (!SWIG_IsOK(ecode1)) {
15285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15286 }
15287 arg1 = static_cast< double >(val1);
15288 }
15289 if (obj1) {
15290 ecode2 = SWIG_AsVal_double(obj1, &val2);
15291 if (!SWIG_IsOK(ecode2)) {
15292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15293 }
15294 arg2 = static_cast< double >(val2);
15295 }
15296 if (obj2) {
15297 ecode3 = SWIG_AsVal_double(obj2, &val3);
15298 if (!SWIG_IsOK(ecode3)) {
15299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15300 }
15301 arg3 = static_cast< double >(val3);
15302 }
15303 {
15304 PyThreadState* __tstate = wxPyBeginAllowThreads();
15305 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15310 return resultobj;
15311 fail:
15312 return NULL;
15313 }
15314
15315
15316 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15317 PyObject *resultobj = 0;
15318 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15319 double arg2 ;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 double val2 ;
15323 int ecode2 = 0 ;
15324 PyObject *swig_obj[2] ;
15325
15326 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15328 if (!SWIG_IsOK(res1)) {
15329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15330 }
15331 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15332 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15333 if (!SWIG_IsOK(ecode2)) {
15334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15335 }
15336 arg2 = static_cast< double >(val2);
15337 if (arg1) (arg1)->hue = arg2;
15338
15339 resultobj = SWIG_Py_Void();
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15347 PyObject *resultobj = 0;
15348 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15349 double result;
15350 void *argp1 = 0 ;
15351 int res1 = 0 ;
15352 PyObject *swig_obj[1] ;
15353
15354 if (!args) SWIG_fail;
15355 swig_obj[0] = args;
15356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15359 }
15360 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15361 result = (double) ((arg1)->hue);
15362 resultobj = SWIG_From_double(static_cast< double >(result));
15363 return resultobj;
15364 fail:
15365 return NULL;
15366 }
15367
15368
15369 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15370 PyObject *resultobj = 0;
15371 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15372 double arg2 ;
15373 void *argp1 = 0 ;
15374 int res1 = 0 ;
15375 double val2 ;
15376 int ecode2 = 0 ;
15377 PyObject *swig_obj[2] ;
15378
15379 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15381 if (!SWIG_IsOK(res1)) {
15382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15383 }
15384 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15385 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15386 if (!SWIG_IsOK(ecode2)) {
15387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15388 }
15389 arg2 = static_cast< double >(val2);
15390 if (arg1) (arg1)->saturation = arg2;
15391
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15402 double result;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15414 result = (double) ((arg1)->saturation);
15415 resultobj = SWIG_From_double(static_cast< double >(result));
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15423 PyObject *resultobj = 0;
15424 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15425 double arg2 ;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 double val2 ;
15429 int ecode2 = 0 ;
15430 PyObject *swig_obj[2] ;
15431
15432 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15434 if (!SWIG_IsOK(res1)) {
15435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15436 }
15437 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15438 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15439 if (!SWIG_IsOK(ecode2)) {
15440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15441 }
15442 arg2 = static_cast< double >(val2);
15443 if (arg1) (arg1)->value = arg2;
15444
15445 resultobj = SWIG_Py_Void();
15446 return resultobj;
15447 fail:
15448 return NULL;
15449 }
15450
15451
15452 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15453 PyObject *resultobj = 0;
15454 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15455 double result;
15456 void *argp1 = 0 ;
15457 int res1 = 0 ;
15458 PyObject *swig_obj[1] ;
15459
15460 if (!args) SWIG_fail;
15461 swig_obj[0] = args;
15462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15463 if (!SWIG_IsOK(res1)) {
15464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15465 }
15466 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15467 result = (double) ((arg1)->value);
15468 resultobj = SWIG_From_double(static_cast< double >(result));
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15476 PyObject *obj;
15477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15478 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15479 return SWIG_Py_Void();
15480 }
15481
15482 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15483 return SWIG_Python_InitShadowInstance(args);
15484 }
15485
15486 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxString *arg1 = 0 ;
15489 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15490 int arg3 = (int) -1 ;
15491 wxImage *result = 0 ;
15492 bool temp1 = false ;
15493 long val2 ;
15494 int ecode2 = 0 ;
15495 int val3 ;
15496 int ecode3 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 PyObject * obj2 = 0 ;
15500 char * kwnames[] = {
15501 (char *) "name",(char *) "type",(char *) "index", NULL
15502 };
15503
15504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15505 {
15506 arg1 = wxString_in_helper(obj0);
15507 if (arg1 == NULL) SWIG_fail;
15508 temp1 = true;
15509 }
15510 if (obj1) {
15511 ecode2 = SWIG_AsVal_long(obj1, &val2);
15512 if (!SWIG_IsOK(ecode2)) {
15513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15514 }
15515 arg2 = static_cast< long >(val2);
15516 }
15517 if (obj2) {
15518 ecode3 = SWIG_AsVal_int(obj2, &val3);
15519 if (!SWIG_IsOK(ecode3)) {
15520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15521 }
15522 arg3 = static_cast< int >(val3);
15523 }
15524 {
15525 PyThreadState* __tstate = wxPyBeginAllowThreads();
15526 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15531 {
15532 if (temp1)
15533 delete arg1;
15534 }
15535 return resultobj;
15536 fail:
15537 {
15538 if (temp1)
15539 delete arg1;
15540 }
15541 return NULL;
15542 }
15543
15544
15545 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15546 PyObject *resultobj = 0;
15547 wxImage *arg1 = (wxImage *) 0 ;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 PyObject *swig_obj[1] ;
15551
15552 if (!args) SWIG_fail;
15553 swig_obj[0] = args;
15554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15555 if (!SWIG_IsOK(res1)) {
15556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15557 }
15558 arg1 = reinterpret_cast< wxImage * >(argp1);
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 delete arg1;
15562
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_Py_Void();
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj = 0;
15575 wxString *arg1 = 0 ;
15576 wxString *arg2 = 0 ;
15577 int arg3 = (int) -1 ;
15578 wxImage *result = 0 ;
15579 bool temp1 = false ;
15580 bool temp2 = false ;
15581 int val3 ;
15582 int ecode3 = 0 ;
15583 PyObject * obj0 = 0 ;
15584 PyObject * obj1 = 0 ;
15585 PyObject * obj2 = 0 ;
15586 char * kwnames[] = {
15587 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15588 };
15589
15590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15591 {
15592 arg1 = wxString_in_helper(obj0);
15593 if (arg1 == NULL) SWIG_fail;
15594 temp1 = true;
15595 }
15596 {
15597 arg2 = wxString_in_helper(obj1);
15598 if (arg2 == NULL) SWIG_fail;
15599 temp2 = true;
15600 }
15601 if (obj2) {
15602 ecode3 = SWIG_AsVal_int(obj2, &val3);
15603 if (!SWIG_IsOK(ecode3)) {
15604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15605 }
15606 arg3 = static_cast< int >(val3);
15607 }
15608 {
15609 PyThreadState* __tstate = wxPyBeginAllowThreads();
15610 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15611 wxPyEndAllowThreads(__tstate);
15612 if (PyErr_Occurred()) SWIG_fail;
15613 }
15614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15615 {
15616 if (temp1)
15617 delete arg1;
15618 }
15619 {
15620 if (temp2)
15621 delete arg2;
15622 }
15623 return resultobj;
15624 fail:
15625 {
15626 if (temp1)
15627 delete arg1;
15628 }
15629 {
15630 if (temp2)
15631 delete arg2;
15632 }
15633 return NULL;
15634 }
15635
15636
15637 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15638 PyObject *resultobj = 0;
15639 wxInputStream *arg1 = 0 ;
15640 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15641 int arg3 = (int) -1 ;
15642 wxImage *result = 0 ;
15643 wxPyInputStream *temp1 ;
15644 bool created1 ;
15645 long val2 ;
15646 int ecode2 = 0 ;
15647 int val3 ;
15648 int ecode3 = 0 ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 PyObject * obj2 = 0 ;
15652 char * kwnames[] = {
15653 (char *) "stream",(char *) "type",(char *) "index", NULL
15654 };
15655
15656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15657 {
15658 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15659 arg1 = temp1->m_wxis;
15660 created1 = false;
15661 } else {
15662 PyErr_Clear(); // clear the failure of the wxPyConvert above
15663 arg1 = wxPyCBInputStream_create(obj0, false);
15664 if (arg1 == NULL) {
15665 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15666 SWIG_fail;
15667 }
15668 created1 = true;
15669 }
15670 }
15671 if (obj1) {
15672 ecode2 = SWIG_AsVal_long(obj1, &val2);
15673 if (!SWIG_IsOK(ecode2)) {
15674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15675 }
15676 arg2 = static_cast< long >(val2);
15677 }
15678 if (obj2) {
15679 ecode3 = SWIG_AsVal_int(obj2, &val3);
15680 if (!SWIG_IsOK(ecode3)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15682 }
15683 arg3 = static_cast< int >(val3);
15684 }
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15692 {
15693 if (created1) delete arg1;
15694 }
15695 return resultobj;
15696 fail:
15697 {
15698 if (created1) delete arg1;
15699 }
15700 return NULL;
15701 }
15702
15703
15704 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15705 PyObject *resultobj = 0;
15706 wxInputStream *arg1 = 0 ;
15707 wxString *arg2 = 0 ;
15708 int arg3 = (int) -1 ;
15709 wxImage *result = 0 ;
15710 wxPyInputStream *temp1 ;
15711 bool created1 ;
15712 bool temp2 = false ;
15713 int val3 ;
15714 int ecode3 = 0 ;
15715 PyObject * obj0 = 0 ;
15716 PyObject * obj1 = 0 ;
15717 PyObject * obj2 = 0 ;
15718 char * kwnames[] = {
15719 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15720 };
15721
15722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15723 {
15724 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15725 arg1 = temp1->m_wxis;
15726 created1 = false;
15727 } else {
15728 PyErr_Clear(); // clear the failure of the wxPyConvert above
15729 arg1 = wxPyCBInputStream_create(obj0, false);
15730 if (arg1 == NULL) {
15731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15732 SWIG_fail;
15733 }
15734 created1 = true;
15735 }
15736 }
15737 {
15738 arg2 = wxString_in_helper(obj1);
15739 if (arg2 == NULL) SWIG_fail;
15740 temp2 = true;
15741 }
15742 if (obj2) {
15743 ecode3 = SWIG_AsVal_int(obj2, &val3);
15744 if (!SWIG_IsOK(ecode3)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15746 }
15747 arg3 = static_cast< int >(val3);
15748 }
15749 {
15750 PyThreadState* __tstate = wxPyBeginAllowThreads();
15751 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15756 {
15757 if (created1) delete arg1;
15758 }
15759 {
15760 if (temp2)
15761 delete arg2;
15762 }
15763 return resultobj;
15764 fail:
15765 {
15766 if (created1) delete arg1;
15767 }
15768 {
15769 if (temp2)
15770 delete arg2;
15771 }
15772 return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj = 0;
15778 int arg1 = (int) 0 ;
15779 int arg2 = (int) 0 ;
15780 bool arg3 = (bool) true ;
15781 wxImage *result = 0 ;
15782 int val1 ;
15783 int ecode1 = 0 ;
15784 int val2 ;
15785 int ecode2 = 0 ;
15786 bool val3 ;
15787 int ecode3 = 0 ;
15788 PyObject * obj0 = 0 ;
15789 PyObject * obj1 = 0 ;
15790 PyObject * obj2 = 0 ;
15791 char * kwnames[] = {
15792 (char *) "width",(char *) "height",(char *) "clear", NULL
15793 };
15794
15795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15796 if (obj0) {
15797 ecode1 = SWIG_AsVal_int(obj0, &val1);
15798 if (!SWIG_IsOK(ecode1)) {
15799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15800 }
15801 arg1 = static_cast< int >(val1);
15802 }
15803 if (obj1) {
15804 ecode2 = SWIG_AsVal_int(obj1, &val2);
15805 if (!SWIG_IsOK(ecode2)) {
15806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15807 }
15808 arg2 = static_cast< int >(val2);
15809 }
15810 if (obj2) {
15811 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15812 if (!SWIG_IsOK(ecode3)) {
15813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15814 }
15815 arg3 = static_cast< bool >(val3);
15816 }
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15831 PyObject *resultobj = 0;
15832 wxBitmap *arg1 = 0 ;
15833 wxImage *result = 0 ;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject * obj0 = 0 ;
15837 char * kwnames[] = {
15838 (char *) "bitmap", NULL
15839 };
15840
15841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15842 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15843 if (!SWIG_IsOK(res1)) {
15844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15845 }
15846 if (!argp1) {
15847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15848 }
15849 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15850 {
15851 if (!wxPyCheckForApp()) SWIG_fail;
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15865 PyObject *resultobj = 0;
15866 int arg1 ;
15867 int arg2 ;
15868 buffer arg3 ;
15869 int arg4 ;
15870 wxImage *result = 0 ;
15871 int val1 ;
15872 int ecode1 = 0 ;
15873 int val2 ;
15874 int ecode2 = 0 ;
15875 Py_ssize_t temp3 ;
15876 PyObject * obj0 = 0 ;
15877 PyObject * obj1 = 0 ;
15878 PyObject * obj2 = 0 ;
15879 char * kwnames[] = {
15880 (char *) "width",(char *) "height",(char *) "data", NULL
15881 };
15882
15883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15884 ecode1 = SWIG_AsVal_int(obj0, &val1);
15885 if (!SWIG_IsOK(ecode1)) {
15886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15887 }
15888 arg1 = static_cast< int >(val1);
15889 ecode2 = SWIG_AsVal_int(obj1, &val2);
15890 if (!SWIG_IsOK(ecode2)) {
15891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15892 }
15893 arg2 = static_cast< int >(val2);
15894 {
15895 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15896 arg4 = (int)temp3;
15897 }
15898 {
15899 PyThreadState* __tstate = wxPyBeginAllowThreads();
15900 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj = 0;
15913 int arg1 ;
15914 int arg2 ;
15915 buffer arg3 ;
15916 int arg4 ;
15917 buffer arg5 ;
15918 int arg6 ;
15919 wxImage *result = 0 ;
15920 int val1 ;
15921 int ecode1 = 0 ;
15922 int val2 ;
15923 int ecode2 = 0 ;
15924 Py_ssize_t temp3 ;
15925 Py_ssize_t temp5 ;
15926 PyObject * obj0 = 0 ;
15927 PyObject * obj1 = 0 ;
15928 PyObject * obj2 = 0 ;
15929 PyObject * obj3 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15935 ecode1 = SWIG_AsVal_int(obj0, &val1);
15936 if (!SWIG_IsOK(ecode1)) {
15937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15938 }
15939 arg1 = static_cast< int >(val1);
15940 ecode2 = SWIG_AsVal_int(obj1, &val2);
15941 if (!SWIG_IsOK(ecode2)) {
15942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15943 }
15944 arg2 = static_cast< int >(val2);
15945 {
15946 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15947 arg4 = (int)temp3;
15948 }
15949 {
15950 if (obj3 != Py_None) {
15951 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15952 arg6 = (int)temp5;
15953 }
15954 }
15955 {
15956 PyThreadState* __tstate = wxPyBeginAllowThreads();
15957 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15958 wxPyEndAllowThreads(__tstate);
15959 if (PyErr_Occurred()) SWIG_fail;
15960 }
15961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15962 return resultobj;
15963 fail:
15964 return NULL;
15965 }
15966
15967
15968 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15969 PyObject *resultobj = 0;
15970 wxImage *arg1 = (wxImage *) 0 ;
15971 int arg2 ;
15972 int arg3 ;
15973 bool arg4 = (bool) true ;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 int val2 ;
15977 int ecode2 = 0 ;
15978 int val3 ;
15979 int ecode3 = 0 ;
15980 bool val4 ;
15981 int ecode4 = 0 ;
15982 PyObject * obj0 = 0 ;
15983 PyObject * obj1 = 0 ;
15984 PyObject * obj2 = 0 ;
15985 PyObject * obj3 = 0 ;
15986 char * kwnames[] = {
15987 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15988 };
15989
15990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15994 }
15995 arg1 = reinterpret_cast< wxImage * >(argp1);
15996 ecode2 = SWIG_AsVal_int(obj1, &val2);
15997 if (!SWIG_IsOK(ecode2)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15999 }
16000 arg2 = static_cast< int >(val2);
16001 ecode3 = SWIG_AsVal_int(obj2, &val3);
16002 if (!SWIG_IsOK(ecode3)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16004 }
16005 arg3 = static_cast< int >(val3);
16006 if (obj3) {
16007 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16008 if (!SWIG_IsOK(ecode4)) {
16009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16010 }
16011 arg4 = static_cast< bool >(val4);
16012 }
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 (arg1)->Create(arg2,arg3,arg4);
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_Py_Void();
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 PyObject *resultobj = 0;
16028 wxImage *arg1 = (wxImage *) 0 ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject *swig_obj[1] ;
16032
16033 if (!args) SWIG_fail;
16034 swig_obj[0] = args;
16035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16038 }
16039 arg1 = reinterpret_cast< wxImage * >(argp1);
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->Destroy();
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_Py_Void();
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj = 0;
16055 wxImage *arg1 = (wxImage *) 0 ;
16056 int arg2 ;
16057 int arg3 ;
16058 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16059 SwigValueWrapper<wxImage > result;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 int val2 ;
16063 int ecode2 = 0 ;
16064 int val3 ;
16065 int ecode3 = 0 ;
16066 int val4 ;
16067 int ecode4 = 0 ;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 PyObject * obj2 = 0 ;
16071 PyObject * obj3 = 0 ;
16072 char * kwnames[] = {
16073 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16074 };
16075
16076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16078 if (!SWIG_IsOK(res1)) {
16079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16080 }
16081 arg1 = reinterpret_cast< wxImage * >(argp1);
16082 ecode2 = SWIG_AsVal_int(obj1, &val2);
16083 if (!SWIG_IsOK(ecode2)) {
16084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16085 }
16086 arg2 = static_cast< int >(val2);
16087 ecode3 = SWIG_AsVal_int(obj2, &val3);
16088 if (!SWIG_IsOK(ecode3)) {
16089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16090 }
16091 arg3 = static_cast< int >(val3);
16092 if (obj3) {
16093 ecode4 = SWIG_AsVal_int(obj3, &val4);
16094 if (!SWIG_IsOK(ecode4)) {
16095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16096 }
16097 arg4 = static_cast< int >(val4);
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (arg1)->Scale(arg2,arg3,arg4);
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj = 0;
16114 wxImage *arg1 = (wxImage *) 0 ;
16115 int arg2 ;
16116 int arg3 ;
16117 SwigValueWrapper<wxImage > result;
16118 void *argp1 = 0 ;
16119 int res1 = 0 ;
16120 int val2 ;
16121 int ecode2 = 0 ;
16122 int val3 ;
16123 int ecode3 = 0 ;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 PyObject * obj2 = 0 ;
16127 char * kwnames[] = {
16128 (char *) "self",(char *) "width",(char *) "height", NULL
16129 };
16130
16131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16135 }
16136 arg1 = reinterpret_cast< wxImage * >(argp1);
16137 ecode2 = SWIG_AsVal_int(obj1, &val2);
16138 if (!SWIG_IsOK(ecode2)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16140 }
16141 arg2 = static_cast< int >(val2);
16142 ecode3 = SWIG_AsVal_int(obj2, &val3);
16143 if (!SWIG_IsOK(ecode3)) {
16144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16145 }
16146 arg3 = static_cast< int >(val3);
16147 {
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj = 0;
16162 wxImage *arg1 = (wxImage *) 0 ;
16163 int arg2 ;
16164 int arg3 ;
16165 SwigValueWrapper<wxImage > result;
16166 void *argp1 = 0 ;
16167 int res1 = 0 ;
16168 int val2 ;
16169 int ecode2 = 0 ;
16170 int val3 ;
16171 int ecode3 = 0 ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 PyObject * obj2 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "self",(char *) "width",(char *) "height", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16181 if (!SWIG_IsOK(res1)) {
16182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16183 }
16184 arg1 = reinterpret_cast< wxImage * >(argp1);
16185 ecode2 = SWIG_AsVal_int(obj1, &val2);
16186 if (!SWIG_IsOK(ecode2)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16188 }
16189 arg2 = static_cast< int >(val2);
16190 ecode3 = SWIG_AsVal_int(obj2, &val3);
16191 if (!SWIG_IsOK(ecode3)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16193 }
16194 arg3 = static_cast< int >(val3);
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj = 0;
16210 wxImage *arg1 = (wxImage *) 0 ;
16211 int arg2 ;
16212 SwigValueWrapper<wxImage > result;
16213 void *argp1 = 0 ;
16214 int res1 = 0 ;
16215 int val2 ;
16216 int ecode2 = 0 ;
16217 PyObject * obj0 = 0 ;
16218 PyObject * obj1 = 0 ;
16219 char * kwnames[] = {
16220 (char *) "self",(char *) "radius", NULL
16221 };
16222
16223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16227 }
16228 arg1 = reinterpret_cast< wxImage * >(argp1);
16229 ecode2 = SWIG_AsVal_int(obj1, &val2);
16230 if (!SWIG_IsOK(ecode2)) {
16231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16232 }
16233 arg2 = static_cast< int >(val2);
16234 {
16235 PyThreadState* __tstate = wxPyBeginAllowThreads();
16236 result = (arg1)->Blur(arg2);
16237 wxPyEndAllowThreads(__tstate);
16238 if (PyErr_Occurred()) SWIG_fail;
16239 }
16240 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16241 return resultobj;
16242 fail:
16243 return NULL;
16244 }
16245
16246
16247 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16248 PyObject *resultobj = 0;
16249 wxImage *arg1 = (wxImage *) 0 ;
16250 int arg2 ;
16251 SwigValueWrapper<wxImage > result;
16252 void *argp1 = 0 ;
16253 int res1 = 0 ;
16254 int val2 ;
16255 int ecode2 = 0 ;
16256 PyObject * obj0 = 0 ;
16257 PyObject * obj1 = 0 ;
16258 char * kwnames[] = {
16259 (char *) "self",(char *) "radius", NULL
16260 };
16261
16262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16264 if (!SWIG_IsOK(res1)) {
16265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16266 }
16267 arg1 = reinterpret_cast< wxImage * >(argp1);
16268 ecode2 = SWIG_AsVal_int(obj1, &val2);
16269 if (!SWIG_IsOK(ecode2)) {
16270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16271 }
16272 arg2 = static_cast< int >(val2);
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (arg1)->BlurHorizontal(arg2);
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16287 PyObject *resultobj = 0;
16288 wxImage *arg1 = (wxImage *) 0 ;
16289 int arg2 ;
16290 SwigValueWrapper<wxImage > result;
16291 void *argp1 = 0 ;
16292 int res1 = 0 ;
16293 int val2 ;
16294 int ecode2 = 0 ;
16295 PyObject * obj0 = 0 ;
16296 PyObject * obj1 = 0 ;
16297 char * kwnames[] = {
16298 (char *) "self",(char *) "radius", NULL
16299 };
16300
16301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16303 if (!SWIG_IsOK(res1)) {
16304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16305 }
16306 arg1 = reinterpret_cast< wxImage * >(argp1);
16307 ecode2 = SWIG_AsVal_int(obj1, &val2);
16308 if (!SWIG_IsOK(ecode2)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16310 }
16311 arg2 = static_cast< int >(val2);
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = (arg1)->BlurVertical(arg2);
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = 0;
16327 wxImage *arg1 = (wxImage *) 0 ;
16328 int arg2 ;
16329 int arg3 ;
16330 SwigValueWrapper<wxImage > result;
16331 void *argp1 = 0 ;
16332 int res1 = 0 ;
16333 int val2 ;
16334 int ecode2 = 0 ;
16335 int val3 ;
16336 int ecode3 = 0 ;
16337 PyObject * obj0 = 0 ;
16338 PyObject * obj1 = 0 ;
16339 PyObject * obj2 = 0 ;
16340 char * kwnames[] = {
16341 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16342 };
16343
16344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16346 if (!SWIG_IsOK(res1)) {
16347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16348 }
16349 arg1 = reinterpret_cast< wxImage * >(argp1);
16350 ecode2 = SWIG_AsVal_int(obj1, &val2);
16351 if (!SWIG_IsOK(ecode2)) {
16352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16353 }
16354 arg2 = static_cast< int >(val2);
16355 ecode3 = SWIG_AsVal_int(obj2, &val3);
16356 if (!SWIG_IsOK(ecode3)) {
16357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16358 }
16359 arg3 = static_cast< int >(val3);
16360 {
16361 PyThreadState* __tstate = wxPyBeginAllowThreads();
16362 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj = 0;
16375 wxImage *arg1 = (wxImage *) 0 ;
16376 int arg2 ;
16377 int arg3 ;
16378 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16379 wxImage *result = 0 ;
16380 void *argp1 = 0 ;
16381 int res1 = 0 ;
16382 int val2 ;
16383 int ecode2 = 0 ;
16384 int val3 ;
16385 int ecode3 = 0 ;
16386 int val4 ;
16387 int ecode4 = 0 ;
16388 PyObject * obj0 = 0 ;
16389 PyObject * obj1 = 0 ;
16390 PyObject * obj2 = 0 ;
16391 PyObject * obj3 = 0 ;
16392 char * kwnames[] = {
16393 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16394 };
16395
16396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16398 if (!SWIG_IsOK(res1)) {
16399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16400 }
16401 arg1 = reinterpret_cast< wxImage * >(argp1);
16402 ecode2 = SWIG_AsVal_int(obj1, &val2);
16403 if (!SWIG_IsOK(ecode2)) {
16404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16405 }
16406 arg2 = static_cast< int >(val2);
16407 ecode3 = SWIG_AsVal_int(obj2, &val3);
16408 if (!SWIG_IsOK(ecode3)) {
16409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16410 }
16411 arg3 = static_cast< int >(val3);
16412 if (obj3) {
16413 ecode4 = SWIG_AsVal_int(obj3, &val4);
16414 if (!SWIG_IsOK(ecode4)) {
16415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16416 }
16417 arg4 = static_cast< int >(val4);
16418 }
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 {
16422 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16423 result = (wxImage *) &_result_ref;
16424 }
16425 wxPyEndAllowThreads(__tstate);
16426 if (PyErr_Occurred()) SWIG_fail;
16427 }
16428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16429 return resultobj;
16430 fail:
16431 return NULL;
16432 }
16433
16434
16435 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16436 PyObject *resultobj = 0;
16437 wxImage *arg1 = (wxImage *) 0 ;
16438 wxSize *arg2 = 0 ;
16439 wxPoint *arg3 = 0 ;
16440 int arg4 = (int) -1 ;
16441 int arg5 = (int) -1 ;
16442 int arg6 = (int) -1 ;
16443 wxImage *result = 0 ;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 wxSize temp2 ;
16447 wxPoint temp3 ;
16448 int val4 ;
16449 int ecode4 = 0 ;
16450 int val5 ;
16451 int ecode5 = 0 ;
16452 int val6 ;
16453 int ecode6 = 0 ;
16454 PyObject * obj0 = 0 ;
16455 PyObject * obj1 = 0 ;
16456 PyObject * obj2 = 0 ;
16457 PyObject * obj3 = 0 ;
16458 PyObject * obj4 = 0 ;
16459 PyObject * obj5 = 0 ;
16460 char * kwnames[] = {
16461 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16462 };
16463
16464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16468 }
16469 arg1 = reinterpret_cast< wxImage * >(argp1);
16470 {
16471 arg2 = &temp2;
16472 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16473 }
16474 {
16475 arg3 = &temp3;
16476 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16477 }
16478 if (obj3) {
16479 ecode4 = SWIG_AsVal_int(obj3, &val4);
16480 if (!SWIG_IsOK(ecode4)) {
16481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16482 }
16483 arg4 = static_cast< int >(val4);
16484 }
16485 if (obj4) {
16486 ecode5 = SWIG_AsVal_int(obj4, &val5);
16487 if (!SWIG_IsOK(ecode5)) {
16488 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16489 }
16490 arg5 = static_cast< int >(val5);
16491 }
16492 if (obj5) {
16493 ecode6 = SWIG_AsVal_int(obj5, &val6);
16494 if (!SWIG_IsOK(ecode6)) {
16495 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16496 }
16497 arg6 = static_cast< int >(val6);
16498 }
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 {
16502 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16503 result = (wxImage *) &_result_ref;
16504 }
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16516 PyObject *resultobj = 0;
16517 wxImage *arg1 = (wxImage *) 0 ;
16518 int arg2 ;
16519 int arg3 ;
16520 byte arg4 ;
16521 byte arg5 ;
16522 byte arg6 ;
16523 void *argp1 = 0 ;
16524 int res1 = 0 ;
16525 int val2 ;
16526 int ecode2 = 0 ;
16527 int val3 ;
16528 int ecode3 = 0 ;
16529 unsigned char val4 ;
16530 int ecode4 = 0 ;
16531 unsigned char val5 ;
16532 int ecode5 = 0 ;
16533 unsigned char val6 ;
16534 int ecode6 = 0 ;
16535 PyObject * obj0 = 0 ;
16536 PyObject * obj1 = 0 ;
16537 PyObject * obj2 = 0 ;
16538 PyObject * obj3 = 0 ;
16539 PyObject * obj4 = 0 ;
16540 PyObject * obj5 = 0 ;
16541 char * kwnames[] = {
16542 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16543 };
16544
16545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16547 if (!SWIG_IsOK(res1)) {
16548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16549 }
16550 arg1 = reinterpret_cast< wxImage * >(argp1);
16551 ecode2 = SWIG_AsVal_int(obj1, &val2);
16552 if (!SWIG_IsOK(ecode2)) {
16553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16554 }
16555 arg2 = static_cast< int >(val2);
16556 ecode3 = SWIG_AsVal_int(obj2, &val3);
16557 if (!SWIG_IsOK(ecode3)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16559 }
16560 arg3 = static_cast< int >(val3);
16561 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16562 if (!SWIG_IsOK(ecode4)) {
16563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16564 }
16565 arg4 = static_cast< byte >(val4);
16566 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16567 if (!SWIG_IsOK(ecode5)) {
16568 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16569 }
16570 arg5 = static_cast< byte >(val5);
16571 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16572 if (!SWIG_IsOK(ecode6)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16574 }
16575 arg6 = static_cast< byte >(val6);
16576 {
16577 PyThreadState* __tstate = wxPyBeginAllowThreads();
16578 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 resultobj = SWIG_Py_Void();
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj = 0;
16591 wxImage *arg1 = (wxImage *) 0 ;
16592 wxRect *arg2 = 0 ;
16593 byte arg3 ;
16594 byte arg4 ;
16595 byte arg5 ;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 wxRect temp2 ;
16599 unsigned char val3 ;
16600 int ecode3 = 0 ;
16601 unsigned char val4 ;
16602 int ecode4 = 0 ;
16603 unsigned char val5 ;
16604 int ecode5 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 PyObject * obj3 = 0 ;
16609 PyObject * obj4 = 0 ;
16610 char * kwnames[] = {
16611 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16612 };
16613
16614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16616 if (!SWIG_IsOK(res1)) {
16617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16618 }
16619 arg1 = reinterpret_cast< wxImage * >(argp1);
16620 {
16621 arg2 = &temp2;
16622 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16623 }
16624 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16625 if (!SWIG_IsOK(ecode3)) {
16626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16627 }
16628 arg3 = static_cast< byte >(val3);
16629 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16630 if (!SWIG_IsOK(ecode4)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16632 }
16633 arg4 = static_cast< byte >(val4);
16634 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16635 if (!SWIG_IsOK(ecode5)) {
16636 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16637 }
16638 arg5 = static_cast< byte >(val5);
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 resultobj = SWIG_Py_Void();
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxImage *arg1 = (wxImage *) 0 ;
16655 int arg2 ;
16656 int arg3 ;
16657 byte result;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 int val2 ;
16661 int ecode2 = 0 ;
16662 int val3 ;
16663 int ecode3 = 0 ;
16664 PyObject * obj0 = 0 ;
16665 PyObject * obj1 = 0 ;
16666 PyObject * obj2 = 0 ;
16667 char * kwnames[] = {
16668 (char *) "self",(char *) "x",(char *) "y", NULL
16669 };
16670
16671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16673 if (!SWIG_IsOK(res1)) {
16674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16675 }
16676 arg1 = reinterpret_cast< wxImage * >(argp1);
16677 ecode2 = SWIG_AsVal_int(obj1, &val2);
16678 if (!SWIG_IsOK(ecode2)) {
16679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16680 }
16681 arg2 = static_cast< int >(val2);
16682 ecode3 = SWIG_AsVal_int(obj2, &val3);
16683 if (!SWIG_IsOK(ecode3)) {
16684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16685 }
16686 arg3 = static_cast< int >(val3);
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = (byte)(arg1)->GetRed(arg2,arg3);
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj = 0;
16702 wxImage *arg1 = (wxImage *) 0 ;
16703 int arg2 ;
16704 int arg3 ;
16705 byte result;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 int val2 ;
16709 int ecode2 = 0 ;
16710 int val3 ;
16711 int ecode3 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 PyObject * obj1 = 0 ;
16714 PyObject * obj2 = 0 ;
16715 char * kwnames[] = {
16716 (char *) "self",(char *) "x",(char *) "y", NULL
16717 };
16718
16719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16721 if (!SWIG_IsOK(res1)) {
16722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16723 }
16724 arg1 = reinterpret_cast< wxImage * >(argp1);
16725 ecode2 = SWIG_AsVal_int(obj1, &val2);
16726 if (!SWIG_IsOK(ecode2)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16728 }
16729 arg2 = static_cast< int >(val2);
16730 ecode3 = SWIG_AsVal_int(obj2, &val3);
16731 if (!SWIG_IsOK(ecode3)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16733 }
16734 arg3 = static_cast< int >(val3);
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = (byte)(arg1)->GetGreen(arg2,arg3);
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxImage *arg1 = (wxImage *) 0 ;
16751 int arg2 ;
16752 int arg3 ;
16753 byte result;
16754 void *argp1 = 0 ;
16755 int res1 = 0 ;
16756 int val2 ;
16757 int ecode2 = 0 ;
16758 int val3 ;
16759 int ecode3 = 0 ;
16760 PyObject * obj0 = 0 ;
16761 PyObject * obj1 = 0 ;
16762 PyObject * obj2 = 0 ;
16763 char * kwnames[] = {
16764 (char *) "self",(char *) "x",(char *) "y", NULL
16765 };
16766
16767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16769 if (!SWIG_IsOK(res1)) {
16770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16771 }
16772 arg1 = reinterpret_cast< wxImage * >(argp1);
16773 ecode2 = SWIG_AsVal_int(obj1, &val2);
16774 if (!SWIG_IsOK(ecode2)) {
16775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16776 }
16777 arg2 = static_cast< int >(val2);
16778 ecode3 = SWIG_AsVal_int(obj2, &val3);
16779 if (!SWIG_IsOK(ecode3)) {
16780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16781 }
16782 arg3 = static_cast< int >(val3);
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (byte)(arg1)->GetBlue(arg2,arg3);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxImage *arg1 = (wxImage *) 0 ;
16799 int arg2 ;
16800 int arg3 ;
16801 byte arg4 ;
16802 void *argp1 = 0 ;
16803 int res1 = 0 ;
16804 int val2 ;
16805 int ecode2 = 0 ;
16806 int val3 ;
16807 int ecode3 = 0 ;
16808 unsigned char val4 ;
16809 int ecode4 = 0 ;
16810 PyObject * obj0 = 0 ;
16811 PyObject * obj1 = 0 ;
16812 PyObject * obj2 = 0 ;
16813 PyObject * obj3 = 0 ;
16814 char * kwnames[] = {
16815 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16816 };
16817
16818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16820 if (!SWIG_IsOK(res1)) {
16821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16822 }
16823 arg1 = reinterpret_cast< wxImage * >(argp1);
16824 ecode2 = SWIG_AsVal_int(obj1, &val2);
16825 if (!SWIG_IsOK(ecode2)) {
16826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16827 }
16828 arg2 = static_cast< int >(val2);
16829 ecode3 = SWIG_AsVal_int(obj2, &val3);
16830 if (!SWIG_IsOK(ecode3)) {
16831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16832 }
16833 arg3 = static_cast< int >(val3);
16834 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16835 if (!SWIG_IsOK(ecode4)) {
16836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16837 }
16838 arg4 = static_cast< byte >(val4);
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 (arg1)->SetAlpha(arg2,arg3,arg4);
16842 wxPyEndAllowThreads(__tstate);
16843 if (PyErr_Occurred()) SWIG_fail;
16844 }
16845 resultobj = SWIG_Py_Void();
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16853 PyObject *resultobj = 0;
16854 wxImage *arg1 = (wxImage *) 0 ;
16855 int arg2 ;
16856 int arg3 ;
16857 byte result;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 int val2 ;
16861 int ecode2 = 0 ;
16862 int val3 ;
16863 int ecode3 = 0 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 PyObject * obj2 = 0 ;
16867 char * kwnames[] = {
16868 (char *) "self",(char *) "x",(char *) "y", NULL
16869 };
16870
16871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16873 if (!SWIG_IsOK(res1)) {
16874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16875 }
16876 arg1 = reinterpret_cast< wxImage * >(argp1);
16877 ecode2 = SWIG_AsVal_int(obj1, &val2);
16878 if (!SWIG_IsOK(ecode2)) {
16879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16880 }
16881 arg2 = static_cast< int >(val2);
16882 ecode3 = SWIG_AsVal_int(obj2, &val3);
16883 if (!SWIG_IsOK(ecode3)) {
16884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16885 }
16886 arg3 = static_cast< int >(val3);
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16894 return resultobj;
16895 fail:
16896 return NULL;
16897 }
16898
16899
16900 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16901 PyObject *resultobj = 0;
16902 wxImage *arg1 = (wxImage *) 0 ;
16903 bool result;
16904 void *argp1 = 0 ;
16905 int res1 = 0 ;
16906 PyObject *swig_obj[1] ;
16907
16908 if (!args) SWIG_fail;
16909 swig_obj[0] = args;
16910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16913 }
16914 arg1 = reinterpret_cast< wxImage * >(argp1);
16915 {
16916 PyThreadState* __tstate = wxPyBeginAllowThreads();
16917 result = (bool)(arg1)->HasAlpha();
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16931 PyObject *resultobj = 0;
16932 wxImage *arg1 = (wxImage *) 0 ;
16933 void *argp1 = 0 ;
16934 int res1 = 0 ;
16935 PyObject *swig_obj[1] ;
16936
16937 if (!args) SWIG_fail;
16938 swig_obj[0] = args;
16939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16940 if (!SWIG_IsOK(res1)) {
16941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16942 }
16943 arg1 = reinterpret_cast< wxImage * >(argp1);
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 (arg1)->InitAlpha();
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 resultobj = SWIG_Py_Void();
16951 return resultobj;
16952 fail:
16953 return NULL;
16954 }
16955
16956
16957 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16958 PyObject *resultobj = 0;
16959 wxImage *arg1 = (wxImage *) 0 ;
16960 int arg2 ;
16961 int arg3 ;
16962 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16963 bool result;
16964 void *argp1 = 0 ;
16965 int res1 = 0 ;
16966 int val2 ;
16967 int ecode2 = 0 ;
16968 int val3 ;
16969 int ecode3 = 0 ;
16970 unsigned char val4 ;
16971 int ecode4 = 0 ;
16972 PyObject * obj0 = 0 ;
16973 PyObject * obj1 = 0 ;
16974 PyObject * obj2 = 0 ;
16975 PyObject * obj3 = 0 ;
16976 char * kwnames[] = {
16977 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16978 };
16979
16980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16982 if (!SWIG_IsOK(res1)) {
16983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16984 }
16985 arg1 = reinterpret_cast< wxImage * >(argp1);
16986 ecode2 = SWIG_AsVal_int(obj1, &val2);
16987 if (!SWIG_IsOK(ecode2)) {
16988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16989 }
16990 arg2 = static_cast< int >(val2);
16991 ecode3 = SWIG_AsVal_int(obj2, &val3);
16992 if (!SWIG_IsOK(ecode3)) {
16993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16994 }
16995 arg3 = static_cast< int >(val3);
16996 if (obj3) {
16997 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16998 if (!SWIG_IsOK(ecode4)) {
16999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17000 }
17001 arg4 = static_cast< byte >(val4);
17002 }
17003 {
17004 PyThreadState* __tstate = wxPyBeginAllowThreads();
17005 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17006 wxPyEndAllowThreads(__tstate);
17007 if (PyErr_Occurred()) SWIG_fail;
17008 }
17009 {
17010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17011 }
17012 return resultobj;
17013 fail:
17014 return NULL;
17015 }
17016
17017
17018 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj = 0;
17020 wxImage *arg1 = (wxImage *) 0 ;
17021 byte *arg2 = (byte *) 0 ;
17022 byte *arg3 = (byte *) 0 ;
17023 byte *arg4 = (byte *) 0 ;
17024 byte arg5 = (byte) 0 ;
17025 byte arg6 = (byte) 0 ;
17026 byte arg7 = (byte) 0 ;
17027 bool result;
17028 void *argp1 = 0 ;
17029 int res1 = 0 ;
17030 byte temp2 ;
17031 int res2 = SWIG_TMPOBJ ;
17032 byte temp3 ;
17033 int res3 = SWIG_TMPOBJ ;
17034 byte temp4 ;
17035 int res4 = SWIG_TMPOBJ ;
17036 unsigned char val5 ;
17037 int ecode5 = 0 ;
17038 unsigned char val6 ;
17039 int ecode6 = 0 ;
17040 unsigned char val7 ;
17041 int ecode7 = 0 ;
17042 PyObject * obj0 = 0 ;
17043 PyObject * obj1 = 0 ;
17044 PyObject * obj2 = 0 ;
17045 PyObject * obj3 = 0 ;
17046 char * kwnames[] = {
17047 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17048 };
17049
17050 arg2 = &temp2;
17051 arg3 = &temp3;
17052 arg4 = &temp4;
17053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17055 if (!SWIG_IsOK(res1)) {
17056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17057 }
17058 arg1 = reinterpret_cast< wxImage * >(argp1);
17059 if (obj1) {
17060 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17061 if (!SWIG_IsOK(ecode5)) {
17062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17063 }
17064 arg5 = static_cast< byte >(val5);
17065 }
17066 if (obj2) {
17067 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17068 if (!SWIG_IsOK(ecode6)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17070 }
17071 arg6 = static_cast< byte >(val6);
17072 }
17073 if (obj3) {
17074 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17075 if (!SWIG_IsOK(ecode7)) {
17076 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17077 }
17078 arg7 = static_cast< byte >(val7);
17079 }
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17083 wxPyEndAllowThreads(__tstate);
17084 if (PyErr_Occurred()) SWIG_fail;
17085 }
17086 {
17087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17088 }
17089 if (SWIG_IsTmpObj(res2)) {
17090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17091 } else {
17092 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17094 }
17095 if (SWIG_IsTmpObj(res3)) {
17096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17097 } else {
17098 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17100 }
17101 if (SWIG_IsTmpObj(res4)) {
17102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17103 } else {
17104 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj = 0;
17115 wxImage *arg1 = (wxImage *) 0 ;
17116 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17117 bool result;
17118 void *argp1 = 0 ;
17119 int res1 = 0 ;
17120 unsigned char val2 ;
17121 int ecode2 = 0 ;
17122 PyObject * obj0 = 0 ;
17123 PyObject * obj1 = 0 ;
17124 char * kwnames[] = {
17125 (char *) "self",(char *) "threshold", NULL
17126 };
17127
17128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17130 if (!SWIG_IsOK(res1)) {
17131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17132 }
17133 arg1 = reinterpret_cast< wxImage * >(argp1);
17134 if (obj1) {
17135 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17136 if (!SWIG_IsOK(ecode2)) {
17137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17138 }
17139 arg2 = static_cast< byte >(val2);
17140 }
17141 {
17142 PyThreadState* __tstate = wxPyBeginAllowThreads();
17143 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17149 }
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj = 0;
17158 wxImage *arg1 = (wxImage *) 0 ;
17159 byte arg2 ;
17160 byte arg3 ;
17161 byte arg4 ;
17162 bool result;
17163 void *argp1 = 0 ;
17164 int res1 = 0 ;
17165 unsigned char val2 ;
17166 int ecode2 = 0 ;
17167 unsigned char val3 ;
17168 int ecode3 = 0 ;
17169 unsigned char val4 ;
17170 int ecode4 = 0 ;
17171 PyObject * obj0 = 0 ;
17172 PyObject * obj1 = 0 ;
17173 PyObject * obj2 = 0 ;
17174 PyObject * obj3 = 0 ;
17175 char * kwnames[] = {
17176 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17177 };
17178
17179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17181 if (!SWIG_IsOK(res1)) {
17182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17183 }
17184 arg1 = reinterpret_cast< wxImage * >(argp1);
17185 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17186 if (!SWIG_IsOK(ecode2)) {
17187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17188 }
17189 arg2 = static_cast< byte >(val2);
17190 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17191 if (!SWIG_IsOK(ecode3)) {
17192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17193 }
17194 arg3 = static_cast< byte >(val3);
17195 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17196 if (!SWIG_IsOK(ecode4)) {
17197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17198 }
17199 arg4 = static_cast< byte >(val4);
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 {
17207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17208 }
17209 return resultobj;
17210 fail:
17211 return NULL;
17212 }
17213
17214
17215 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17216 PyObject *resultobj = 0;
17217 wxImage *arg1 = (wxImage *) 0 ;
17218 wxImage *arg2 = 0 ;
17219 byte arg3 ;
17220 byte arg4 ;
17221 byte arg5 ;
17222 bool result;
17223 void *argp1 = 0 ;
17224 int res1 = 0 ;
17225 void *argp2 = 0 ;
17226 int res2 = 0 ;
17227 unsigned char val3 ;
17228 int ecode3 = 0 ;
17229 unsigned char val4 ;
17230 int ecode4 = 0 ;
17231 unsigned char val5 ;
17232 int ecode5 = 0 ;
17233 PyObject * obj0 = 0 ;
17234 PyObject * obj1 = 0 ;
17235 PyObject * obj2 = 0 ;
17236 PyObject * obj3 = 0 ;
17237 PyObject * obj4 = 0 ;
17238 char * kwnames[] = {
17239 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17240 };
17241
17242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17244 if (!SWIG_IsOK(res1)) {
17245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17246 }
17247 arg1 = reinterpret_cast< wxImage * >(argp1);
17248 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17249 if (!SWIG_IsOK(res2)) {
17250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17251 }
17252 if (!argp2) {
17253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17254 }
17255 arg2 = reinterpret_cast< wxImage * >(argp2);
17256 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17257 if (!SWIG_IsOK(ecode3)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17259 }
17260 arg3 = static_cast< byte >(val3);
17261 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17262 if (!SWIG_IsOK(ecode4)) {
17263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17264 }
17265 arg4 = static_cast< byte >(val4);
17266 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17267 if (!SWIG_IsOK(ecode5)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17269 }
17270 arg5 = static_cast< byte >(val5);
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17274 wxPyEndAllowThreads(__tstate);
17275 if (PyErr_Occurred()) SWIG_fail;
17276 }
17277 {
17278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17279 }
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17287 PyObject *resultobj = 0;
17288 wxString *arg1 = 0 ;
17289 bool result;
17290 bool temp1 = false ;
17291 PyObject * obj0 = 0 ;
17292 char * kwnames[] = {
17293 (char *) "filename", NULL
17294 };
17295
17296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17297 {
17298 arg1 = wxString_in_helper(obj0);
17299 if (arg1 == NULL) SWIG_fail;
17300 temp1 = true;
17301 }
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 {
17309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17310 }
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 return resultobj;
17316 fail:
17317 {
17318 if (temp1)
17319 delete arg1;
17320 }
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17326 PyObject *resultobj = 0;
17327 wxString *arg1 = 0 ;
17328 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17329 int result;
17330 bool temp1 = false ;
17331 long val2 ;
17332 int ecode2 = 0 ;
17333 PyObject * obj0 = 0 ;
17334 PyObject * obj1 = 0 ;
17335 char * kwnames[] = {
17336 (char *) "filename",(char *) "type", NULL
17337 };
17338
17339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17340 {
17341 arg1 = wxString_in_helper(obj0);
17342 if (arg1 == NULL) SWIG_fail;
17343 temp1 = true;
17344 }
17345 if (obj1) {
17346 ecode2 = SWIG_AsVal_long(obj1, &val2);
17347 if (!SWIG_IsOK(ecode2)) {
17348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17349 }
17350 arg2 = static_cast< long >(val2);
17351 }
17352 {
17353 PyThreadState* __tstate = wxPyBeginAllowThreads();
17354 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 resultobj = SWIG_From_int(static_cast< int >(result));
17359 {
17360 if (temp1)
17361 delete arg1;
17362 }
17363 return resultobj;
17364 fail:
17365 {
17366 if (temp1)
17367 delete arg1;
17368 }
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj = 0;
17375 wxImage *arg1 = (wxImage *) 0 ;
17376 wxString *arg2 = 0 ;
17377 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17378 int arg4 = (int) -1 ;
17379 bool result;
17380 void *argp1 = 0 ;
17381 int res1 = 0 ;
17382 bool temp2 = false ;
17383 long val3 ;
17384 int ecode3 = 0 ;
17385 int val4 ;
17386 int ecode4 = 0 ;
17387 PyObject * obj0 = 0 ;
17388 PyObject * obj1 = 0 ;
17389 PyObject * obj2 = 0 ;
17390 PyObject * obj3 = 0 ;
17391 char * kwnames[] = {
17392 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17393 };
17394
17395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17397 if (!SWIG_IsOK(res1)) {
17398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17399 }
17400 arg1 = reinterpret_cast< wxImage * >(argp1);
17401 {
17402 arg2 = wxString_in_helper(obj1);
17403 if (arg2 == NULL) SWIG_fail;
17404 temp2 = true;
17405 }
17406 if (obj2) {
17407 ecode3 = SWIG_AsVal_long(obj2, &val3);
17408 if (!SWIG_IsOK(ecode3)) {
17409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17410 }
17411 arg3 = static_cast< long >(val3);
17412 }
17413 if (obj3) {
17414 ecode4 = SWIG_AsVal_int(obj3, &val4);
17415 if (!SWIG_IsOK(ecode4)) {
17416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17417 }
17418 arg4 = static_cast< int >(val4);
17419 }
17420 {
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 {
17427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17428 }
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp2)
17437 delete arg2;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj = 0;
17445 wxImage *arg1 = (wxImage *) 0 ;
17446 wxString *arg2 = 0 ;
17447 wxString *arg3 = 0 ;
17448 int arg4 = (int) -1 ;
17449 bool result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 bool temp2 = false ;
17453 bool temp3 = false ;
17454 int val4 ;
17455 int ecode4 = 0 ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 PyObject * obj2 = 0 ;
17459 PyObject * obj3 = 0 ;
17460 char * kwnames[] = {
17461 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17462 };
17463
17464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17466 if (!SWIG_IsOK(res1)) {
17467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17468 }
17469 arg1 = reinterpret_cast< wxImage * >(argp1);
17470 {
17471 arg2 = wxString_in_helper(obj1);
17472 if (arg2 == NULL) SWIG_fail;
17473 temp2 = true;
17474 }
17475 {
17476 arg3 = wxString_in_helper(obj2);
17477 if (arg3 == NULL) SWIG_fail;
17478 temp3 = true;
17479 }
17480 if (obj3) {
17481 ecode4 = SWIG_AsVal_int(obj3, &val4);
17482 if (!SWIG_IsOK(ecode4)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17484 }
17485 arg4 = static_cast< int >(val4);
17486 }
17487 {
17488 PyThreadState* __tstate = wxPyBeginAllowThreads();
17489 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 {
17494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17495 }
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 {
17501 if (temp3)
17502 delete arg3;
17503 }
17504 return resultobj;
17505 fail:
17506 {
17507 if (temp2)
17508 delete arg2;
17509 }
17510 {
17511 if (temp3)
17512 delete arg3;
17513 }
17514 return NULL;
17515 }
17516
17517
17518 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17519 PyObject *resultobj = 0;
17520 wxImage *arg1 = (wxImage *) 0 ;
17521 wxString *arg2 = 0 ;
17522 int arg3 ;
17523 bool result;
17524 void *argp1 = 0 ;
17525 int res1 = 0 ;
17526 bool temp2 = false ;
17527 int val3 ;
17528 int ecode3 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 PyObject * obj1 = 0 ;
17531 PyObject * obj2 = 0 ;
17532 char * kwnames[] = {
17533 (char *) "self",(char *) "name",(char *) "type", NULL
17534 };
17535
17536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17538 if (!SWIG_IsOK(res1)) {
17539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17540 }
17541 arg1 = reinterpret_cast< wxImage * >(argp1);
17542 {
17543 arg2 = wxString_in_helper(obj1);
17544 if (arg2 == NULL) SWIG_fail;
17545 temp2 = true;
17546 }
17547 ecode3 = SWIG_AsVal_int(obj2, &val3);
17548 if (!SWIG_IsOK(ecode3)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17550 }
17551 arg3 = static_cast< int >(val3);
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 {
17559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17560 }
17561 {
17562 if (temp2)
17563 delete arg2;
17564 }
17565 return resultobj;
17566 fail:
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj = 0;
17577 wxImage *arg1 = (wxImage *) 0 ;
17578 wxString *arg2 = 0 ;
17579 wxString *arg3 = 0 ;
17580 bool result;
17581 void *argp1 = 0 ;
17582 int res1 = 0 ;
17583 bool temp2 = false ;
17584 bool temp3 = false ;
17585 PyObject * obj0 = 0 ;
17586 PyObject * obj1 = 0 ;
17587 PyObject * obj2 = 0 ;
17588 char * kwnames[] = {
17589 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17590 };
17591
17592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17594 if (!SWIG_IsOK(res1)) {
17595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17596 }
17597 arg1 = reinterpret_cast< wxImage * >(argp1);
17598 {
17599 arg2 = wxString_in_helper(obj1);
17600 if (arg2 == NULL) SWIG_fail;
17601 temp2 = true;
17602 }
17603 {
17604 arg3 = wxString_in_helper(obj2);
17605 if (arg3 == NULL) SWIG_fail;
17606 temp3 = true;
17607 }
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17616 }
17617 {
17618 if (temp2)
17619 delete arg2;
17620 }
17621 {
17622 if (temp3)
17623 delete arg3;
17624 }
17625 return resultobj;
17626 fail:
17627 {
17628 if (temp2)
17629 delete arg2;
17630 }
17631 {
17632 if (temp3)
17633 delete arg3;
17634 }
17635 return NULL;
17636 }
17637
17638
17639 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj = 0;
17641 wxInputStream *arg1 = 0 ;
17642 bool result;
17643 wxPyInputStream *temp1 ;
17644 bool created1 ;
17645 PyObject * obj0 = 0 ;
17646 char * kwnames[] = {
17647 (char *) "stream", NULL
17648 };
17649
17650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17651 {
17652 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17653 arg1 = temp1->m_wxis;
17654 created1 = false;
17655 } else {
17656 PyErr_Clear(); // clear the failure of the wxPyConvert above
17657 arg1 = wxPyCBInputStream_create(obj0, false);
17658 if (arg1 == NULL) {
17659 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17660 SWIG_fail;
17661 }
17662 created1 = true;
17663 }
17664 }
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)wxImage::CanRead(*arg1);
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 {
17672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17673 }
17674 {
17675 if (created1) delete arg1;
17676 }
17677 return resultobj;
17678 fail:
17679 {
17680 if (created1) delete arg1;
17681 }
17682 return NULL;
17683 }
17684
17685
17686 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj = 0;
17688 wxImage *arg1 = (wxImage *) 0 ;
17689 wxInputStream *arg2 = 0 ;
17690 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17691 int arg4 = (int) -1 ;
17692 bool result;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 wxPyInputStream *temp2 ;
17696 bool created2 ;
17697 long val3 ;
17698 int ecode3 = 0 ;
17699 int val4 ;
17700 int ecode4 = 0 ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 PyObject * obj2 = 0 ;
17704 PyObject * obj3 = 0 ;
17705 char * kwnames[] = {
17706 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17707 };
17708
17709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17711 if (!SWIG_IsOK(res1)) {
17712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17713 }
17714 arg1 = reinterpret_cast< wxImage * >(argp1);
17715 {
17716 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17717 arg2 = temp2->m_wxis;
17718 created2 = false;
17719 } else {
17720 PyErr_Clear(); // clear the failure of the wxPyConvert above
17721 arg2 = wxPyCBInputStream_create(obj1, false);
17722 if (arg2 == NULL) {
17723 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17724 SWIG_fail;
17725 }
17726 created2 = true;
17727 }
17728 }
17729 if (obj2) {
17730 ecode3 = SWIG_AsVal_long(obj2, &val3);
17731 if (!SWIG_IsOK(ecode3)) {
17732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17733 }
17734 arg3 = static_cast< long >(val3);
17735 }
17736 if (obj3) {
17737 ecode4 = SWIG_AsVal_int(obj3, &val4);
17738 if (!SWIG_IsOK(ecode4)) {
17739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17740 }
17741 arg4 = static_cast< int >(val4);
17742 }
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 {
17753 if (created2) delete arg2;
17754 }
17755 return resultobj;
17756 fail:
17757 {
17758 if (created2) delete arg2;
17759 }
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxImage *arg1 = (wxImage *) 0 ;
17767 wxInputStream *arg2 = 0 ;
17768 wxString *arg3 = 0 ;
17769 int arg4 = (int) -1 ;
17770 bool result;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 wxPyInputStream *temp2 ;
17774 bool created2 ;
17775 bool temp3 = false ;
17776 int val4 ;
17777 int ecode4 = 0 ;
17778 PyObject * obj0 = 0 ;
17779 PyObject * obj1 = 0 ;
17780 PyObject * obj2 = 0 ;
17781 PyObject * obj3 = 0 ;
17782 char * kwnames[] = {
17783 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17784 };
17785
17786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17788 if (!SWIG_IsOK(res1)) {
17789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17790 }
17791 arg1 = reinterpret_cast< wxImage * >(argp1);
17792 {
17793 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17794 arg2 = temp2->m_wxis;
17795 created2 = false;
17796 } else {
17797 PyErr_Clear(); // clear the failure of the wxPyConvert above
17798 arg2 = wxPyCBInputStream_create(obj1, false);
17799 if (arg2 == NULL) {
17800 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17801 SWIG_fail;
17802 }
17803 created2 = true;
17804 }
17805 }
17806 {
17807 arg3 = wxString_in_helper(obj2);
17808 if (arg3 == NULL) SWIG_fail;
17809 temp3 = true;
17810 }
17811 if (obj3) {
17812 ecode4 = SWIG_AsVal_int(obj3, &val4);
17813 if (!SWIG_IsOK(ecode4)) {
17814 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17815 }
17816 arg4 = static_cast< int >(val4);
17817 }
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 {
17825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17826 }
17827 {
17828 if (created2) delete arg2;
17829 }
17830 {
17831 if (temp3)
17832 delete arg3;
17833 }
17834 return resultobj;
17835 fail:
17836 {
17837 if (created2) delete arg2;
17838 }
17839 {
17840 if (temp3)
17841 delete arg3;
17842 }
17843 return NULL;
17844 }
17845
17846
17847 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17848 PyObject *resultobj = 0;
17849 wxImage *arg1 = (wxImage *) 0 ;
17850 bool result;
17851 void *argp1 = 0 ;
17852 int res1 = 0 ;
17853 PyObject *swig_obj[1] ;
17854
17855 if (!args) SWIG_fail;
17856 swig_obj[0] = args;
17857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17860 }
17861 arg1 = reinterpret_cast< wxImage * >(argp1);
17862 {
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 result = (bool)(arg1)->IsOk();
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 {
17869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17870 }
17871 return resultobj;
17872 fail:
17873 return NULL;
17874 }
17875
17876
17877 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17878 PyObject *resultobj = 0;
17879 wxImage *arg1 = (wxImage *) 0 ;
17880 int result;
17881 void *argp1 = 0 ;
17882 int res1 = 0 ;
17883 PyObject *swig_obj[1] ;
17884
17885 if (!args) SWIG_fail;
17886 swig_obj[0] = args;
17887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17888 if (!SWIG_IsOK(res1)) {
17889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17890 }
17891 arg1 = reinterpret_cast< wxImage * >(argp1);
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = (int)(arg1)->GetWidth();
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 resultobj = SWIG_From_int(static_cast< int >(result));
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17906 PyObject *resultobj = 0;
17907 wxImage *arg1 = (wxImage *) 0 ;
17908 int result;
17909 void *argp1 = 0 ;
17910 int res1 = 0 ;
17911 PyObject *swig_obj[1] ;
17912
17913 if (!args) SWIG_fail;
17914 swig_obj[0] = args;
17915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17916 if (!SWIG_IsOK(res1)) {
17917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17918 }
17919 arg1 = reinterpret_cast< wxImage * >(argp1);
17920 {
17921 PyThreadState* __tstate = wxPyBeginAllowThreads();
17922 result = (int)(arg1)->GetHeight();
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 resultobj = SWIG_From_int(static_cast< int >(result));
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17934 PyObject *resultobj = 0;
17935 wxImage *arg1 = (wxImage *) 0 ;
17936 wxSize result;
17937 void *argp1 = 0 ;
17938 int res1 = 0 ;
17939 PyObject *swig_obj[1] ;
17940
17941 if (!args) SWIG_fail;
17942 swig_obj[0] = args;
17943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17944 if (!SWIG_IsOK(res1)) {
17945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17946 }
17947 arg1 = reinterpret_cast< wxImage * >(argp1);
17948 {
17949 PyThreadState* __tstate = wxPyBeginAllowThreads();
17950 result = wxImage_GetSize(arg1);
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj = 0;
17963 wxImage *arg1 = (wxImage *) 0 ;
17964 wxRect *arg2 = 0 ;
17965 SwigValueWrapper<wxImage > result;
17966 void *argp1 = 0 ;
17967 int res1 = 0 ;
17968 wxRect temp2 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char * kwnames[] = {
17972 (char *) "self",(char *) "rect", NULL
17973 };
17974
17975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17979 }
17980 arg1 = reinterpret_cast< wxImage * >(argp1);
17981 {
17982 arg2 = &temp2;
17983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17984 }
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17992 return resultobj;
17993 fail:
17994 return NULL;
17995 }
17996
17997
17998 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17999 PyObject *resultobj = 0;
18000 wxImage *arg1 = (wxImage *) 0 ;
18001 wxSize *arg2 = 0 ;
18002 wxPoint *arg3 = 0 ;
18003 int arg4 = (int) -1 ;
18004 int arg5 = (int) -1 ;
18005 int arg6 = (int) -1 ;
18006 SwigValueWrapper<wxImage > result;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 wxSize temp2 ;
18010 wxPoint temp3 ;
18011 int val4 ;
18012 int ecode4 = 0 ;
18013 int val5 ;
18014 int ecode5 = 0 ;
18015 int val6 ;
18016 int ecode6 = 0 ;
18017 PyObject * obj0 = 0 ;
18018 PyObject * obj1 = 0 ;
18019 PyObject * obj2 = 0 ;
18020 PyObject * obj3 = 0 ;
18021 PyObject * obj4 = 0 ;
18022 PyObject * obj5 = 0 ;
18023 char * kwnames[] = {
18024 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18025 };
18026
18027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18029 if (!SWIG_IsOK(res1)) {
18030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18031 }
18032 arg1 = reinterpret_cast< wxImage * >(argp1);
18033 {
18034 arg2 = &temp2;
18035 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18036 }
18037 {
18038 arg3 = &temp3;
18039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18040 }
18041 if (obj3) {
18042 ecode4 = SWIG_AsVal_int(obj3, &val4);
18043 if (!SWIG_IsOK(ecode4)) {
18044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18045 }
18046 arg4 = static_cast< int >(val4);
18047 }
18048 if (obj4) {
18049 ecode5 = SWIG_AsVal_int(obj4, &val5);
18050 if (!SWIG_IsOK(ecode5)) {
18051 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18052 }
18053 arg5 = static_cast< int >(val5);
18054 }
18055 if (obj5) {
18056 ecode6 = SWIG_AsVal_int(obj5, &val6);
18057 if (!SWIG_IsOK(ecode6)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18059 }
18060 arg6 = static_cast< int >(val6);
18061 }
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *resultobj = 0;
18077 wxImage *arg1 = (wxImage *) 0 ;
18078 SwigValueWrapper<wxImage > result;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 PyObject *swig_obj[1] ;
18082
18083 if (!args) SWIG_fail;
18084 swig_obj[0] = args;
18085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18088 }
18089 arg1 = reinterpret_cast< wxImage * >(argp1);
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (arg1)->Copy();
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18104 PyObject *resultobj = 0;
18105 wxImage *arg1 = (wxImage *) 0 ;
18106 wxImage *arg2 = 0 ;
18107 int arg3 ;
18108 int arg4 ;
18109 void *argp1 = 0 ;
18110 int res1 = 0 ;
18111 void *argp2 = 0 ;
18112 int res2 = 0 ;
18113 int val3 ;
18114 int ecode3 = 0 ;
18115 int val4 ;
18116 int ecode4 = 0 ;
18117 PyObject * obj0 = 0 ;
18118 PyObject * obj1 = 0 ;
18119 PyObject * obj2 = 0 ;
18120 PyObject * obj3 = 0 ;
18121 char * kwnames[] = {
18122 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18123 };
18124
18125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18127 if (!SWIG_IsOK(res1)) {
18128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18129 }
18130 arg1 = reinterpret_cast< wxImage * >(argp1);
18131 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18132 if (!SWIG_IsOK(res2)) {
18133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18134 }
18135 if (!argp2) {
18136 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18137 }
18138 arg2 = reinterpret_cast< wxImage * >(argp2);
18139 ecode3 = SWIG_AsVal_int(obj2, &val3);
18140 if (!SWIG_IsOK(ecode3)) {
18141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18142 }
18143 arg3 = static_cast< int >(val3);
18144 ecode4 = SWIG_AsVal_int(obj3, &val4);
18145 if (!SWIG_IsOK(ecode4)) {
18146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18147 }
18148 arg4 = static_cast< int >(val4);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxImage *arg1 = (wxImage *) 0 ;
18165 PyObject *result = 0 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 PyObject *swig_obj[1] ;
18169
18170 if (!args) SWIG_fail;
18171 swig_obj[0] = args;
18172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18175 }
18176 arg1 = reinterpret_cast< wxImage * >(argp1);
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxImage_GetData(arg1);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18191 PyObject *resultobj = 0;
18192 wxImage *arg1 = (wxImage *) 0 ;
18193 buffer arg2 ;
18194 int arg3 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 Py_ssize_t temp2 ;
18198 PyObject * obj0 = 0 ;
18199 PyObject * obj1 = 0 ;
18200 char * kwnames[] = {
18201 (char *) "self",(char *) "data", NULL
18202 };
18203
18204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18206 if (!SWIG_IsOK(res1)) {
18207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18208 }
18209 arg1 = reinterpret_cast< wxImage * >(argp1);
18210 {
18211 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18212 arg3 = (int)temp2;
18213 }
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 wxImage_SetData(arg1,arg2,arg3);
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = SWIG_Py_Void();
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18228 PyObject *resultobj = 0;
18229 wxImage *arg1 = (wxImage *) 0 ;
18230 PyObject *result = 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 PyObject *swig_obj[1] ;
18234
18235 if (!args) SWIG_fail;
18236 swig_obj[0] = args;
18237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18238 if (!SWIG_IsOK(res1)) {
18239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18240 }
18241 arg1 = reinterpret_cast< wxImage * >(argp1);
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 resultobj = result;
18249 return resultobj;
18250 fail:
18251 return NULL;
18252 }
18253
18254
18255 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18256 PyObject *resultobj = 0;
18257 wxImage *arg1 = (wxImage *) 0 ;
18258 buffer arg2 ;
18259 int arg3 ;
18260 void *argp1 = 0 ;
18261 int res1 = 0 ;
18262 Py_ssize_t temp2 ;
18263 PyObject * obj0 = 0 ;
18264 PyObject * obj1 = 0 ;
18265 char * kwnames[] = {
18266 (char *) "self",(char *) "data", NULL
18267 };
18268
18269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18271 if (!SWIG_IsOK(res1)) {
18272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18273 }
18274 arg1 = reinterpret_cast< wxImage * >(argp1);
18275 {
18276 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18277 arg3 = (int)temp2;
18278 }
18279 {
18280 PyThreadState* __tstate = wxPyBeginAllowThreads();
18281 wxImage_SetDataBuffer(arg1,arg2,arg3);
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 resultobj = SWIG_Py_Void();
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18293 PyObject *resultobj = 0;
18294 wxImage *arg1 = (wxImage *) 0 ;
18295 PyObject *result = 0 ;
18296 void *argp1 = 0 ;
18297 int res1 = 0 ;
18298 PyObject *swig_obj[1] ;
18299
18300 if (!args) SWIG_fail;
18301 swig_obj[0] = args;
18302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18305 }
18306 arg1 = reinterpret_cast< wxImage * >(argp1);
18307 {
18308 PyThreadState* __tstate = wxPyBeginAllowThreads();
18309 result = (PyObject *)wxImage_GetAlphaData(arg1);
18310 wxPyEndAllowThreads(__tstate);
18311 if (PyErr_Occurred()) SWIG_fail;
18312 }
18313 resultobj = result;
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj = 0;
18322 wxImage *arg1 = (wxImage *) 0 ;
18323 buffer arg2 ;
18324 int arg3 ;
18325 void *argp1 = 0 ;
18326 int res1 = 0 ;
18327 Py_ssize_t temp2 ;
18328 PyObject * obj0 = 0 ;
18329 PyObject * obj1 = 0 ;
18330 char * kwnames[] = {
18331 (char *) "self",(char *) "alpha", NULL
18332 };
18333
18334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18336 if (!SWIG_IsOK(res1)) {
18337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18338 }
18339 arg1 = reinterpret_cast< wxImage * >(argp1);
18340 {
18341 if (obj1 != Py_None) {
18342 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18343 arg3 = (int)temp2;
18344 }
18345 }
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 wxImage_SetAlphaData(arg1,arg2,arg3);
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = SWIG_Py_Void();
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18360 PyObject *resultobj = 0;
18361 wxImage *arg1 = (wxImage *) 0 ;
18362 PyObject *result = 0 ;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 PyObject *swig_obj[1] ;
18366
18367 if (!args) SWIG_fail;
18368 swig_obj[0] = args;
18369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18370 if (!SWIG_IsOK(res1)) {
18371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18372 }
18373 arg1 = reinterpret_cast< wxImage * >(argp1);
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18377 wxPyEndAllowThreads(__tstate);
18378 if (PyErr_Occurred()) SWIG_fail;
18379 }
18380 resultobj = result;
18381 return resultobj;
18382 fail:
18383 return NULL;
18384 }
18385
18386
18387 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj = 0;
18389 wxImage *arg1 = (wxImage *) 0 ;
18390 buffer arg2 ;
18391 int arg3 ;
18392 void *argp1 = 0 ;
18393 int res1 = 0 ;
18394 Py_ssize_t temp2 ;
18395 PyObject * obj0 = 0 ;
18396 PyObject * obj1 = 0 ;
18397 char * kwnames[] = {
18398 (char *) "self",(char *) "alpha", NULL
18399 };
18400
18401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18403 if (!SWIG_IsOK(res1)) {
18404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18405 }
18406 arg1 = reinterpret_cast< wxImage * >(argp1);
18407 {
18408 if (obj1 != Py_None) {
18409 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18410 arg3 = (int)temp2;
18411 }
18412 }
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_Py_Void();
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18427 PyObject *resultobj = 0;
18428 wxImage *arg1 = (wxImage *) 0 ;
18429 byte arg2 ;
18430 byte arg3 ;
18431 byte arg4 ;
18432 void *argp1 = 0 ;
18433 int res1 = 0 ;
18434 unsigned char val2 ;
18435 int ecode2 = 0 ;
18436 unsigned char val3 ;
18437 int ecode3 = 0 ;
18438 unsigned char val4 ;
18439 int ecode4 = 0 ;
18440 PyObject * obj0 = 0 ;
18441 PyObject * obj1 = 0 ;
18442 PyObject * obj2 = 0 ;
18443 PyObject * obj3 = 0 ;
18444 char * kwnames[] = {
18445 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18446 };
18447
18448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18452 }
18453 arg1 = reinterpret_cast< wxImage * >(argp1);
18454 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18455 if (!SWIG_IsOK(ecode2)) {
18456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18457 }
18458 arg2 = static_cast< byte >(val2);
18459 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18460 if (!SWIG_IsOK(ecode3)) {
18461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18462 }
18463 arg3 = static_cast< byte >(val3);
18464 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18465 if (!SWIG_IsOK(ecode4)) {
18466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18467 }
18468 arg4 = static_cast< byte >(val4);
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 (arg1)->SetMaskColour(arg2,arg3,arg4);
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 resultobj = SWIG_Py_Void();
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18483 PyObject *resultobj = 0;
18484 wxImage *arg1 = (wxImage *) 0 ;
18485 byte *arg2 = (byte *) 0 ;
18486 byte *arg3 = (byte *) 0 ;
18487 byte *arg4 = (byte *) 0 ;
18488 void *argp1 = 0 ;
18489 int res1 = 0 ;
18490 byte temp2 ;
18491 int res2 = SWIG_TMPOBJ ;
18492 byte temp3 ;
18493 int res3 = SWIG_TMPOBJ ;
18494 byte temp4 ;
18495 int res4 = SWIG_TMPOBJ ;
18496 PyObject *swig_obj[1] ;
18497
18498 arg2 = &temp2;
18499 arg3 = &temp3;
18500 arg4 = &temp4;
18501 if (!args) SWIG_fail;
18502 swig_obj[0] = args;
18503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18504 if (!SWIG_IsOK(res1)) {
18505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18506 }
18507 arg1 = reinterpret_cast< wxImage * >(argp1);
18508 {
18509 PyThreadState* __tstate = wxPyBeginAllowThreads();
18510 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18511 wxPyEndAllowThreads(__tstate);
18512 if (PyErr_Occurred()) SWIG_fail;
18513 }
18514 resultobj = SWIG_Py_Void();
18515 if (SWIG_IsTmpObj(res2)) {
18516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18517 } else {
18518 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18520 }
18521 if (SWIG_IsTmpObj(res3)) {
18522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18523 } else {
18524 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18526 }
18527 if (SWIG_IsTmpObj(res4)) {
18528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18529 } else {
18530 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18532 }
18533 return resultobj;
18534 fail:
18535 return NULL;
18536 }
18537
18538
18539 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18540 PyObject *resultobj = 0;
18541 wxImage *arg1 = (wxImage *) 0 ;
18542 byte result;
18543 void *argp1 = 0 ;
18544 int res1 = 0 ;
18545 PyObject *swig_obj[1] ;
18546
18547 if (!args) SWIG_fail;
18548 swig_obj[0] = args;
18549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18550 if (!SWIG_IsOK(res1)) {
18551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18552 }
18553 arg1 = reinterpret_cast< wxImage * >(argp1);
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 result = (byte)(arg1)->GetMaskRed();
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18561 return resultobj;
18562 fail:
18563 return NULL;
18564 }
18565
18566
18567 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18568 PyObject *resultobj = 0;
18569 wxImage *arg1 = (wxImage *) 0 ;
18570 byte result;
18571 void *argp1 = 0 ;
18572 int res1 = 0 ;
18573 PyObject *swig_obj[1] ;
18574
18575 if (!args) SWIG_fail;
18576 swig_obj[0] = args;
18577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18580 }
18581 arg1 = reinterpret_cast< wxImage * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (byte)(arg1)->GetMaskGreen();
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18596 PyObject *resultobj = 0;
18597 wxImage *arg1 = (wxImage *) 0 ;
18598 byte result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 PyObject *swig_obj[1] ;
18602
18603 if (!args) SWIG_fail;
18604 swig_obj[0] = args;
18605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18608 }
18609 arg1 = reinterpret_cast< wxImage * >(argp1);
18610 {
18611 PyThreadState* __tstate = wxPyBeginAllowThreads();
18612 result = (byte)(arg1)->GetMaskBlue();
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj = 0;
18625 wxImage *arg1 = (wxImage *) 0 ;
18626 bool arg2 = (bool) true ;
18627 void *argp1 = 0 ;
18628 int res1 = 0 ;
18629 bool val2 ;
18630 int ecode2 = 0 ;
18631 PyObject * obj0 = 0 ;
18632 PyObject * obj1 = 0 ;
18633 char * kwnames[] = {
18634 (char *) "self",(char *) "mask", NULL
18635 };
18636
18637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18639 if (!SWIG_IsOK(res1)) {
18640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18641 }
18642 arg1 = reinterpret_cast< wxImage * >(argp1);
18643 if (obj1) {
18644 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18645 if (!SWIG_IsOK(ecode2)) {
18646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18647 }
18648 arg2 = static_cast< bool >(val2);
18649 }
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 (arg1)->SetMask(arg2);
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 resultobj = SWIG_Py_Void();
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxImage *arg1 = (wxImage *) 0 ;
18666 bool result;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18676 }
18677 arg1 = reinterpret_cast< wxImage * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (bool)(arg1)->HasMask();
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 {
18685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18686 }
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18694 PyObject *resultobj = 0;
18695 wxImage *arg1 = (wxImage *) 0 ;
18696 double arg2 ;
18697 wxPoint *arg3 = 0 ;
18698 bool arg4 = (bool) true ;
18699 wxPoint *arg5 = (wxPoint *) NULL ;
18700 SwigValueWrapper<wxImage > result;
18701 void *argp1 = 0 ;
18702 int res1 = 0 ;
18703 double val2 ;
18704 int ecode2 = 0 ;
18705 wxPoint temp3 ;
18706 bool val4 ;
18707 int ecode4 = 0 ;
18708 void *argp5 = 0 ;
18709 int res5 = 0 ;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 PyObject * obj2 = 0 ;
18713 PyObject * obj3 = 0 ;
18714 PyObject * obj4 = 0 ;
18715 char * kwnames[] = {
18716 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18717 };
18718
18719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18721 if (!SWIG_IsOK(res1)) {
18722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18723 }
18724 arg1 = reinterpret_cast< wxImage * >(argp1);
18725 ecode2 = SWIG_AsVal_double(obj1, &val2);
18726 if (!SWIG_IsOK(ecode2)) {
18727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18728 }
18729 arg2 = static_cast< double >(val2);
18730 {
18731 arg3 = &temp3;
18732 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18733 }
18734 if (obj3) {
18735 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18736 if (!SWIG_IsOK(ecode4)) {
18737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18738 }
18739 arg4 = static_cast< bool >(val4);
18740 }
18741 if (obj4) {
18742 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18743 if (!SWIG_IsOK(res5)) {
18744 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18745 }
18746 arg5 = reinterpret_cast< wxPoint * >(argp5);
18747 }
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj = 0;
18763 wxImage *arg1 = (wxImage *) 0 ;
18764 bool arg2 = (bool) true ;
18765 SwigValueWrapper<wxImage > result;
18766 void *argp1 = 0 ;
18767 int res1 = 0 ;
18768 bool val2 ;
18769 int ecode2 = 0 ;
18770 PyObject * obj0 = 0 ;
18771 PyObject * obj1 = 0 ;
18772 char * kwnames[] = {
18773 (char *) "self",(char *) "clockwise", NULL
18774 };
18775
18776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18778 if (!SWIG_IsOK(res1)) {
18779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18780 }
18781 arg1 = reinterpret_cast< wxImage * >(argp1);
18782 if (obj1) {
18783 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18784 if (!SWIG_IsOK(ecode2)) {
18785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18786 }
18787 arg2 = static_cast< bool >(val2);
18788 }
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (arg1)->Rotate90(arg2);
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj = 0;
18804 wxImage *arg1 = (wxImage *) 0 ;
18805 bool arg2 = (bool) true ;
18806 SwigValueWrapper<wxImage > result;
18807 void *argp1 = 0 ;
18808 int res1 = 0 ;
18809 bool val2 ;
18810 int ecode2 = 0 ;
18811 PyObject * obj0 = 0 ;
18812 PyObject * obj1 = 0 ;
18813 char * kwnames[] = {
18814 (char *) "self",(char *) "horizontally", NULL
18815 };
18816
18817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18819 if (!SWIG_IsOK(res1)) {
18820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18821 }
18822 arg1 = reinterpret_cast< wxImage * >(argp1);
18823 if (obj1) {
18824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18825 if (!SWIG_IsOK(ecode2)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18827 }
18828 arg2 = static_cast< bool >(val2);
18829 }
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (arg1)->Mirror(arg2);
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxImage *arg1 = (wxImage *) 0 ;
18846 byte arg2 ;
18847 byte arg3 ;
18848 byte arg4 ;
18849 byte arg5 ;
18850 byte arg6 ;
18851 byte arg7 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 unsigned char val2 ;
18855 int ecode2 = 0 ;
18856 unsigned char val3 ;
18857 int ecode3 = 0 ;
18858 unsigned char val4 ;
18859 int ecode4 = 0 ;
18860 unsigned char val5 ;
18861 int ecode5 = 0 ;
18862 unsigned char val6 ;
18863 int ecode6 = 0 ;
18864 unsigned char val7 ;
18865 int ecode7 = 0 ;
18866 PyObject * obj0 = 0 ;
18867 PyObject * obj1 = 0 ;
18868 PyObject * obj2 = 0 ;
18869 PyObject * obj3 = 0 ;
18870 PyObject * obj4 = 0 ;
18871 PyObject * obj5 = 0 ;
18872 PyObject * obj6 = 0 ;
18873 char * kwnames[] = {
18874 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18875 };
18876
18877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18879 if (!SWIG_IsOK(res1)) {
18880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18881 }
18882 arg1 = reinterpret_cast< wxImage * >(argp1);
18883 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18884 if (!SWIG_IsOK(ecode2)) {
18885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18886 }
18887 arg2 = static_cast< byte >(val2);
18888 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18889 if (!SWIG_IsOK(ecode3)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18891 }
18892 arg3 = static_cast< byte >(val3);
18893 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18894 if (!SWIG_IsOK(ecode4)) {
18895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18896 }
18897 arg4 = static_cast< byte >(val4);
18898 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18899 if (!SWIG_IsOK(ecode5)) {
18900 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18901 }
18902 arg5 = static_cast< byte >(val5);
18903 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18904 if (!SWIG_IsOK(ecode6)) {
18905 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18906 }
18907 arg6 = static_cast< byte >(val6);
18908 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18909 if (!SWIG_IsOK(ecode7)) {
18910 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18911 }
18912 arg7 = static_cast< byte >(val7);
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 resultobj = SWIG_Py_Void();
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj = 0;
18928 wxImage *arg1 = (wxImage *) 0 ;
18929 double arg2 = (double) 0.299 ;
18930 double arg3 = (double) 0.587 ;
18931 double arg4 = (double) 0.114 ;
18932 SwigValueWrapper<wxImage > result;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 double val2 ;
18936 int ecode2 = 0 ;
18937 double val3 ;
18938 int ecode3 = 0 ;
18939 double val4 ;
18940 int ecode4 = 0 ;
18941 PyObject * obj0 = 0 ;
18942 PyObject * obj1 = 0 ;
18943 PyObject * obj2 = 0 ;
18944 PyObject * obj3 = 0 ;
18945 char * kwnames[] = {
18946 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18947 };
18948
18949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18953 }
18954 arg1 = reinterpret_cast< wxImage * >(argp1);
18955 if (obj1) {
18956 ecode2 = SWIG_AsVal_double(obj1, &val2);
18957 if (!SWIG_IsOK(ecode2)) {
18958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18959 }
18960 arg2 = static_cast< double >(val2);
18961 }
18962 if (obj2) {
18963 ecode3 = SWIG_AsVal_double(obj2, &val3);
18964 if (!SWIG_IsOK(ecode3)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18966 }
18967 arg3 = static_cast< double >(val3);
18968 }
18969 if (obj3) {
18970 ecode4 = SWIG_AsVal_double(obj3, &val4);
18971 if (!SWIG_IsOK(ecode4)) {
18972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18973 }
18974 arg4 = static_cast< double >(val4);
18975 }
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18979 wxPyEndAllowThreads(__tstate);
18980 if (PyErr_Occurred()) SWIG_fail;
18981 }
18982 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj = 0;
18991 wxImage *arg1 = (wxImage *) 0 ;
18992 byte arg2 ;
18993 byte arg3 ;
18994 byte arg4 ;
18995 SwigValueWrapper<wxImage > result;
18996 void *argp1 = 0 ;
18997 int res1 = 0 ;
18998 unsigned char val2 ;
18999 int ecode2 = 0 ;
19000 unsigned char val3 ;
19001 int ecode3 = 0 ;
19002 unsigned char val4 ;
19003 int ecode4 = 0 ;
19004 PyObject * obj0 = 0 ;
19005 PyObject * obj1 = 0 ;
19006 PyObject * obj2 = 0 ;
19007 PyObject * obj3 = 0 ;
19008 char * kwnames[] = {
19009 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19010 };
19011
19012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19014 if (!SWIG_IsOK(res1)) {
19015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19016 }
19017 arg1 = reinterpret_cast< wxImage * >(argp1);
19018 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19019 if (!SWIG_IsOK(ecode2)) {
19020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19021 }
19022 arg2 = static_cast< byte >(val2);
19023 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19024 if (!SWIG_IsOK(ecode3)) {
19025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19026 }
19027 arg3 = static_cast< byte >(val3);
19028 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19029 if (!SWIG_IsOK(ecode4)) {
19030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19031 }
19032 arg4 = static_cast< byte >(val4);
19033 {
19034 PyThreadState* __tstate = wxPyBeginAllowThreads();
19035 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj = 0;
19048 wxImage *arg1 = (wxImage *) 0 ;
19049 wxString *arg2 = 0 ;
19050 wxString *arg3 = 0 ;
19051 void *argp1 = 0 ;
19052 int res1 = 0 ;
19053 bool temp2 = false ;
19054 bool temp3 = false ;
19055 PyObject * obj0 = 0 ;
19056 PyObject * obj1 = 0 ;
19057 PyObject * obj2 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "self",(char *) "name",(char *) "value", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19064 if (!SWIG_IsOK(res1)) {
19065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19066 }
19067 arg1 = reinterpret_cast< wxImage * >(argp1);
19068 {
19069 arg2 = wxString_in_helper(obj1);
19070 if (arg2 == NULL) SWIG_fail;
19071 temp2 = true;
19072 }
19073 {
19074 arg3 = wxString_in_helper(obj2);
19075 if (arg3 == NULL) SWIG_fail;
19076 temp3 = true;
19077 }
19078 {
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19081 wxPyEndAllowThreads(__tstate);
19082 if (PyErr_Occurred()) SWIG_fail;
19083 }
19084 resultobj = SWIG_Py_Void();
19085 {
19086 if (temp2)
19087 delete arg2;
19088 }
19089 {
19090 if (temp3)
19091 delete arg3;
19092 }
19093 return resultobj;
19094 fail:
19095 {
19096 if (temp2)
19097 delete arg2;
19098 }
19099 {
19100 if (temp3)
19101 delete arg3;
19102 }
19103 return NULL;
19104 }
19105
19106
19107 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19108 PyObject *resultobj = 0;
19109 wxImage *arg1 = (wxImage *) 0 ;
19110 wxString *arg2 = 0 ;
19111 int arg3 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 bool temp2 = false ;
19115 int val3 ;
19116 int ecode3 = 0 ;
19117 PyObject * obj0 = 0 ;
19118 PyObject * obj1 = 0 ;
19119 PyObject * obj2 = 0 ;
19120 char * kwnames[] = {
19121 (char *) "self",(char *) "name",(char *) "value", NULL
19122 };
19123
19124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19126 if (!SWIG_IsOK(res1)) {
19127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19128 }
19129 arg1 = reinterpret_cast< wxImage * >(argp1);
19130 {
19131 arg2 = wxString_in_helper(obj1);
19132 if (arg2 == NULL) SWIG_fail;
19133 temp2 = true;
19134 }
19135 ecode3 = SWIG_AsVal_int(obj2, &val3);
19136 if (!SWIG_IsOK(ecode3)) {
19137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19138 }
19139 arg3 = static_cast< int >(val3);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 (arg1)->SetOption((wxString const &)*arg2,arg3);
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 resultobj = SWIG_Py_Void();
19147 {
19148 if (temp2)
19149 delete arg2;
19150 }
19151 return resultobj;
19152 fail:
19153 {
19154 if (temp2)
19155 delete arg2;
19156 }
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj = 0;
19163 wxImage *arg1 = (wxImage *) 0 ;
19164 wxString *arg2 = 0 ;
19165 wxString result;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 bool temp2 = false ;
19169 PyObject * obj0 = 0 ;
19170 PyObject * obj1 = 0 ;
19171 char * kwnames[] = {
19172 (char *) "self",(char *) "name", NULL
19173 };
19174
19175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19179 }
19180 arg1 = reinterpret_cast< wxImage * >(argp1);
19181 {
19182 arg2 = wxString_in_helper(obj1);
19183 if (arg2 == NULL) SWIG_fail;
19184 temp2 = true;
19185 }
19186 {
19187 PyThreadState* __tstate = wxPyBeginAllowThreads();
19188 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19189 wxPyEndAllowThreads(__tstate);
19190 if (PyErr_Occurred()) SWIG_fail;
19191 }
19192 {
19193 #if wxUSE_UNICODE
19194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19195 #else
19196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19197 #endif
19198 }
19199 {
19200 if (temp2)
19201 delete arg2;
19202 }
19203 return resultobj;
19204 fail:
19205 {
19206 if (temp2)
19207 delete arg2;
19208 }
19209 return NULL;
19210 }
19211
19212
19213 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj = 0;
19215 wxImage *arg1 = (wxImage *) 0 ;
19216 wxString *arg2 = 0 ;
19217 int result;
19218 void *argp1 = 0 ;
19219 int res1 = 0 ;
19220 bool temp2 = false ;
19221 PyObject * obj0 = 0 ;
19222 PyObject * obj1 = 0 ;
19223 char * kwnames[] = {
19224 (char *) "self",(char *) "name", NULL
19225 };
19226
19227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19231 }
19232 arg1 = reinterpret_cast< wxImage * >(argp1);
19233 {
19234 arg2 = wxString_in_helper(obj1);
19235 if (arg2 == NULL) SWIG_fail;
19236 temp2 = true;
19237 }
19238 {
19239 PyThreadState* __tstate = wxPyBeginAllowThreads();
19240 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 resultobj = SWIG_From_int(static_cast< int >(result));
19245 {
19246 if (temp2)
19247 delete arg2;
19248 }
19249 return resultobj;
19250 fail:
19251 {
19252 if (temp2)
19253 delete arg2;
19254 }
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj = 0;
19261 wxImage *arg1 = (wxImage *) 0 ;
19262 wxString *arg2 = 0 ;
19263 bool result;
19264 void *argp1 = 0 ;
19265 int res1 = 0 ;
19266 bool temp2 = false ;
19267 PyObject * obj0 = 0 ;
19268 PyObject * obj1 = 0 ;
19269 char * kwnames[] = {
19270 (char *) "self",(char *) "name", NULL
19271 };
19272
19273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19275 if (!SWIG_IsOK(res1)) {
19276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19277 }
19278 arg1 = reinterpret_cast< wxImage * >(argp1);
19279 {
19280 arg2 = wxString_in_helper(obj1);
19281 if (arg2 == NULL) SWIG_fail;
19282 temp2 = true;
19283 }
19284 {
19285 PyThreadState* __tstate = wxPyBeginAllowThreads();
19286 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19287 wxPyEndAllowThreads(__tstate);
19288 if (PyErr_Occurred()) SWIG_fail;
19289 }
19290 {
19291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19292 }
19293 {
19294 if (temp2)
19295 delete arg2;
19296 }
19297 return resultobj;
19298 fail:
19299 {
19300 if (temp2)
19301 delete arg2;
19302 }
19303 return NULL;
19304 }
19305
19306
19307 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19308 PyObject *resultobj = 0;
19309 wxImage *arg1 = (wxImage *) 0 ;
19310 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19311 unsigned long result;
19312 void *argp1 = 0 ;
19313 int res1 = 0 ;
19314 unsigned long val2 ;
19315 int ecode2 = 0 ;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char * kwnames[] = {
19319 (char *) "self",(char *) "stopafter", NULL
19320 };
19321
19322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19324 if (!SWIG_IsOK(res1)) {
19325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19326 }
19327 arg1 = reinterpret_cast< wxImage * >(argp1);
19328 if (obj1) {
19329 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19330 if (!SWIG_IsOK(ecode2)) {
19331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19332 }
19333 arg2 = static_cast< unsigned long >(val2);
19334 }
19335 {
19336 PyThreadState* __tstate = wxPyBeginAllowThreads();
19337 result = (unsigned long)(arg1)->CountColours(arg2);
19338 wxPyEndAllowThreads(__tstate);
19339 if (PyErr_Occurred()) SWIG_fail;
19340 }
19341 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj = 0;
19350 wxImage *arg1 = (wxImage *) 0 ;
19351 wxImageHistogram *arg2 = 0 ;
19352 unsigned long result;
19353 void *argp1 = 0 ;
19354 int res1 = 0 ;
19355 void *argp2 = 0 ;
19356 int res2 = 0 ;
19357 PyObject * obj0 = 0 ;
19358 PyObject * obj1 = 0 ;
19359 char * kwnames[] = {
19360 (char *) "self",(char *) "h", NULL
19361 };
19362
19363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19365 if (!SWIG_IsOK(res1)) {
19366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19367 }
19368 arg1 = reinterpret_cast< wxImage * >(argp1);
19369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19370 if (!SWIG_IsOK(res2)) {
19371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19372 }
19373 if (!argp2) {
19374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19375 }
19376 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19391 PyObject *resultobj = 0;
19392 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19393 void *argp1 = 0 ;
19394 int res1 = 0 ;
19395 PyObject * obj0 = 0 ;
19396 char * kwnames[] = {
19397 (char *) "handler", NULL
19398 };
19399
19400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19402 if (!SWIG_IsOK(res1)) {
19403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19404 }
19405 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 wxImage::AddHandler(arg1);
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 resultobj = SWIG_Py_Void();
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = 0;
19421 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19422 void *argp1 = 0 ;
19423 int res1 = 0 ;
19424 PyObject * obj0 = 0 ;
19425 char * kwnames[] = {
19426 (char *) "handler", NULL
19427 };
19428
19429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19431 if (!SWIG_IsOK(res1)) {
19432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19433 }
19434 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 wxImage::InsertHandler(arg1);
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_Py_Void();
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj = 0;
19450 wxString *arg1 = 0 ;
19451 bool result;
19452 bool temp1 = false ;
19453 PyObject * obj0 = 0 ;
19454 char * kwnames[] = {
19455 (char *) "name", NULL
19456 };
19457
19458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19459 {
19460 arg1 = wxString_in_helper(obj0);
19461 if (arg1 == NULL) SWIG_fail;
19462 temp1 = true;
19463 }
19464 {
19465 PyThreadState* __tstate = wxPyBeginAllowThreads();
19466 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 {
19471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19472 }
19473 {
19474 if (temp1)
19475 delete arg1;
19476 }
19477 return resultobj;
19478 fail:
19479 {
19480 if (temp1)
19481 delete arg1;
19482 }
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *resultobj = 0;
19489 PyObject *result = 0 ;
19490
19491 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19492 {
19493 PyThreadState* __tstate = wxPyBeginAllowThreads();
19494 result = (PyObject *)wxImage_GetHandlers();
19495 wxPyEndAllowThreads(__tstate);
19496 if (PyErr_Occurred()) SWIG_fail;
19497 }
19498 resultobj = result;
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19506 PyObject *resultobj = 0;
19507 wxString result;
19508
19509 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19510 {
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 result = wxImage::GetImageExtWildcard();
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 {
19517 #if wxUSE_UNICODE
19518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19519 #else
19520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19521 #endif
19522 }
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj = 0;
19531 wxImage *arg1 = (wxImage *) 0 ;
19532 int arg2 = (int) -1 ;
19533 wxBitmap result;
19534 void *argp1 = 0 ;
19535 int res1 = 0 ;
19536 int val2 ;
19537 int ecode2 = 0 ;
19538 PyObject * obj0 = 0 ;
19539 PyObject * obj1 = 0 ;
19540 char * kwnames[] = {
19541 (char *) "self",(char *) "depth", NULL
19542 };
19543
19544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19546 if (!SWIG_IsOK(res1)) {
19547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19548 }
19549 arg1 = reinterpret_cast< wxImage * >(argp1);
19550 if (obj1) {
19551 ecode2 = SWIG_AsVal_int(obj1, &val2);
19552 if (!SWIG_IsOK(ecode2)) {
19553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19554 }
19555 arg2 = static_cast< int >(val2);
19556 }
19557 {
19558 if (!wxPyCheckForApp()) SWIG_fail;
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = wxImage_ConvertToBitmap(arg1,arg2);
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19572 PyObject *resultobj = 0;
19573 wxImage *arg1 = (wxImage *) 0 ;
19574 byte arg2 ;
19575 byte arg3 ;
19576 byte arg4 ;
19577 wxBitmap result;
19578 void *argp1 = 0 ;
19579 int res1 = 0 ;
19580 unsigned char val2 ;
19581 int ecode2 = 0 ;
19582 unsigned char val3 ;
19583 int ecode3 = 0 ;
19584 unsigned char val4 ;
19585 int ecode4 = 0 ;
19586 PyObject * obj0 = 0 ;
19587 PyObject * obj1 = 0 ;
19588 PyObject * obj2 = 0 ;
19589 PyObject * obj3 = 0 ;
19590 char * kwnames[] = {
19591 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19592 };
19593
19594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19596 if (!SWIG_IsOK(res1)) {
19597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19598 }
19599 arg1 = reinterpret_cast< wxImage * >(argp1);
19600 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19601 if (!SWIG_IsOK(ecode2)) {
19602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19603 }
19604 arg2 = static_cast< byte >(val2);
19605 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19606 if (!SWIG_IsOK(ecode3)) {
19607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19608 }
19609 arg3 = static_cast< byte >(val3);
19610 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19611 if (!SWIG_IsOK(ecode4)) {
19612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19613 }
19614 arg4 = static_cast< byte >(val4);
19615 {
19616 if (!wxPyCheckForApp()) SWIG_fail;
19617 PyThreadState* __tstate = wxPyBeginAllowThreads();
19618 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj = 0;
19631 wxImage *arg1 = (wxImage *) 0 ;
19632 double arg2 ;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 double val2 ;
19636 int ecode2 = 0 ;
19637 PyObject * obj0 = 0 ;
19638 PyObject * obj1 = 0 ;
19639 char * kwnames[] = {
19640 (char *) "self",(char *) "angle", NULL
19641 };
19642
19643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19645 if (!SWIG_IsOK(res1)) {
19646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19647 }
19648 arg1 = reinterpret_cast< wxImage * >(argp1);
19649 ecode2 = SWIG_AsVal_double(obj1, &val2);
19650 if (!SWIG_IsOK(ecode2)) {
19651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19652 }
19653 arg2 = static_cast< double >(val2);
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 (arg1)->RotateHue(arg2);
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 resultobj = SWIG_Py_Void();
19661 return resultobj;
19662 fail:
19663 return NULL;
19664 }
19665
19666
19667 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19668 PyObject *resultobj = 0;
19669 wxImage_RGBValue arg1 ;
19670 wxImage_HSVValue result;
19671 void *argp1 ;
19672 int res1 = 0 ;
19673 PyObject * obj0 = 0 ;
19674 char * kwnames[] = {
19675 (char *) "rgb", NULL
19676 };
19677
19678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19679 {
19680 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19681 if (!SWIG_IsOK(res1)) {
19682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19683 }
19684 if (!argp1) {
19685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19686 } else {
19687 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19688 arg1 = *temp;
19689 if (SWIG_IsNewObj(res1)) delete temp;
19690 }
19691 }
19692 {
19693 PyThreadState* __tstate = wxPyBeginAllowThreads();
19694 result = wxImage::RGBtoHSV(arg1);
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19706 PyObject *resultobj = 0;
19707 wxImage_HSVValue arg1 ;
19708 wxImage_RGBValue result;
19709 void *argp1 ;
19710 int res1 = 0 ;
19711 PyObject * obj0 = 0 ;
19712 char * kwnames[] = {
19713 (char *) "hsv", NULL
19714 };
19715
19716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19717 {
19718 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19719 if (!SWIG_IsOK(res1)) {
19720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19721 }
19722 if (!argp1) {
19723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19724 } else {
19725 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19726 arg1 = *temp;
19727 if (SWIG_IsNewObj(res1)) delete temp;
19728 }
19729 }
19730 {
19731 PyThreadState* __tstate = wxPyBeginAllowThreads();
19732 result = wxImage::HSVtoRGB(arg1);
19733 wxPyEndAllowThreads(__tstate);
19734 if (PyErr_Occurred()) SWIG_fail;
19735 }
19736 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19737 return resultobj;
19738 fail:
19739 return NULL;
19740 }
19741
19742
19743 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19744 PyObject *obj;
19745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19746 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19747 return SWIG_Py_Void();
19748 }
19749
19750 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19751 return SWIG_Python_InitShadowInstance(args);
19752 }
19753
19754 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19755 PyObject *resultobj = 0;
19756 int arg1 ;
19757 int arg2 ;
19758 buffer arg3 ;
19759 int arg4 ;
19760 buffer arg5 = (buffer) NULL ;
19761 int arg6 = (int) 0 ;
19762 wxImage *result = 0 ;
19763 int val1 ;
19764 int ecode1 = 0 ;
19765 int val2 ;
19766 int ecode2 = 0 ;
19767 Py_ssize_t temp3 ;
19768 Py_ssize_t temp5 ;
19769 PyObject * obj0 = 0 ;
19770 PyObject * obj1 = 0 ;
19771 PyObject * obj2 = 0 ;
19772 PyObject * obj3 = 0 ;
19773 char * kwnames[] = {
19774 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19775 };
19776
19777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19778 ecode1 = SWIG_AsVal_int(obj0, &val1);
19779 if (!SWIG_IsOK(ecode1)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19781 }
19782 arg1 = static_cast< int >(val1);
19783 ecode2 = SWIG_AsVal_int(obj1, &val2);
19784 if (!SWIG_IsOK(ecode2)) {
19785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19786 }
19787 arg2 = static_cast< int >(val2);
19788 {
19789 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19790 arg4 = (int)temp3;
19791 }
19792 if (obj3) {
19793 {
19794 if (obj3 != Py_None) {
19795 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19796 arg6 = (int)temp5;
19797 }
19798 }
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 {
19807 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19808 }
19809 return resultobj;
19810 fail:
19811 return NULL;
19812 }
19813
19814
19815 SWIGINTERN int NullImage_set(PyObject *) {
19816 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19817 return 1;
19818 }
19819
19820
19821 SWIGINTERN PyObject *NullImage_get(void) {
19822 PyObject *pyobj = 0;
19823
19824 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19825 return pyobj;
19826 }
19827
19828
19829 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19830 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19831 return 1;
19832 }
19833
19834
19835 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19836 PyObject *pyobj = 0;
19837
19838 {
19839 #if wxUSE_UNICODE
19840 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19841 #else
19842 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19843 #endif
19844 }
19845 return pyobj;
19846 }
19847
19848
19849 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19850 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19851 return 1;
19852 }
19853
19854
19855 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19856 PyObject *pyobj = 0;
19857
19858 {
19859 #if wxUSE_UNICODE
19860 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19861 #else
19862 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19863 #endif
19864 }
19865 return pyobj;
19866 }
19867
19868
19869 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19870 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19871 return 1;
19872 }
19873
19874
19875 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19876 PyObject *pyobj = 0;
19877
19878 {
19879 #if wxUSE_UNICODE
19880 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19881 #else
19882 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19883 #endif
19884 }
19885 return pyobj;
19886 }
19887
19888
19889 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19890 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19891 return 1;
19892 }
19893
19894
19895 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19896 PyObject *pyobj = 0;
19897
19898 {
19899 #if wxUSE_UNICODE
19900 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19901 #else
19902 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19903 #endif
19904 }
19905 return pyobj;
19906 }
19907
19908
19909 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19910 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19911 return 1;
19912 }
19913
19914
19915 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19916 PyObject *pyobj = 0;
19917
19918 {
19919 #if wxUSE_UNICODE
19920 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19921 #else
19922 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19923 #endif
19924 }
19925 return pyobj;
19926 }
19927
19928
19929 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19930 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19931 return 1;
19932 }
19933
19934
19935 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19936 PyObject *pyobj = 0;
19937
19938 {
19939 #if wxUSE_UNICODE
19940 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19941 #else
19942 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19943 #endif
19944 }
19945 return pyobj;
19946 }
19947
19948
19949 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19950 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19951 return 1;
19952 }
19953
19954
19955 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19956 PyObject *pyobj = 0;
19957
19958 {
19959 #if wxUSE_UNICODE
19960 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19961 #else
19962 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19963 #endif
19964 }
19965 return pyobj;
19966 }
19967
19968
19969 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19970 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19971 return 1;
19972 }
19973
19974
19975 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19976 PyObject *pyobj = 0;
19977
19978 {
19979 #if wxUSE_UNICODE
19980 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19981 #else
19982 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19983 #endif
19984 }
19985 return pyobj;
19986 }
19987
19988
19989 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19990 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19991 return 1;
19992 }
19993
19994
19995 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19996 PyObject *pyobj = 0;
19997
19998 {
19999 #if wxUSE_UNICODE
20000 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20001 #else
20002 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20003 #endif
20004 }
20005 return pyobj;
20006 }
20007
20008
20009 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20010 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20011 return 1;
20012 }
20013
20014
20015 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20016 PyObject *pyobj = 0;
20017
20018 {
20019 #if wxUSE_UNICODE
20020 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20021 #else
20022 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20023 #endif
20024 }
20025 return pyobj;
20026 }
20027
20028
20029 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20030 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20031 return 1;
20032 }
20033
20034
20035 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20036 PyObject *pyobj = 0;
20037
20038 {
20039 #if wxUSE_UNICODE
20040 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20041 #else
20042 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20043 #endif
20044 }
20045 return pyobj;
20046 }
20047
20048
20049 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20050 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20051 return 1;
20052 }
20053
20054
20055 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20056 PyObject *pyobj = 0;
20057
20058 {
20059 #if wxUSE_UNICODE
20060 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20061 #else
20062 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20063 #endif
20064 }
20065 return pyobj;
20066 }
20067
20068
20069 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20070 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20071 return 1;
20072 }
20073
20074
20075 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20076 PyObject *pyobj = 0;
20077
20078 {
20079 #if wxUSE_UNICODE
20080 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20081 #else
20082 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20083 #endif
20084 }
20085 return pyobj;
20086 }
20087
20088
20089 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20090 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20091 return 1;
20092 }
20093
20094
20095 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20096 PyObject *pyobj = 0;
20097
20098 {
20099 #if wxUSE_UNICODE
20100 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20101 #else
20102 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20103 #endif
20104 }
20105 return pyobj;
20106 }
20107
20108
20109 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20110 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20111 return 1;
20112 }
20113
20114
20115 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20116 PyObject *pyobj = 0;
20117
20118 {
20119 #if wxUSE_UNICODE
20120 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20121 #else
20122 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20123 #endif
20124 }
20125 return pyobj;
20126 }
20127
20128
20129 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20130 PyObject *resultobj = 0;
20131 wxBMPHandler *result = 0 ;
20132
20133 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (wxBMPHandler *)new wxBMPHandler();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *obj;
20149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20150 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20151 return SWIG_Py_Void();
20152 }
20153
20154 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20155 return SWIG_Python_InitShadowInstance(args);
20156 }
20157
20158 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20159 PyObject *resultobj = 0;
20160 wxICOHandler *result = 0 ;
20161
20162 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20163 {
20164 PyThreadState* __tstate = wxPyBeginAllowThreads();
20165 result = (wxICOHandler *)new wxICOHandler();
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 PyObject *obj;
20178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20179 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20180 return SWIG_Py_Void();
20181 }
20182
20183 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20184 return SWIG_Python_InitShadowInstance(args);
20185 }
20186
20187 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20188 PyObject *resultobj = 0;
20189 wxCURHandler *result = 0 ;
20190
20191 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20192 {
20193 PyThreadState* __tstate = wxPyBeginAllowThreads();
20194 result = (wxCURHandler *)new wxCURHandler();
20195 wxPyEndAllowThreads(__tstate);
20196 if (PyErr_Occurred()) SWIG_fail;
20197 }
20198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206 PyObject *obj;
20207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20208 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20209 return SWIG_Py_Void();
20210 }
20211
20212 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 return SWIG_Python_InitShadowInstance(args);
20214 }
20215
20216 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 PyObject *resultobj = 0;
20218 wxANIHandler *result = 0 ;
20219
20220 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 result = (wxANIHandler *)new wxANIHandler();
20224 wxPyEndAllowThreads(__tstate);
20225 if (PyErr_Occurred()) SWIG_fail;
20226 }
20227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20235 PyObject *obj;
20236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20237 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20238 return SWIG_Py_Void();
20239 }
20240
20241 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20242 return SWIG_Python_InitShadowInstance(args);
20243 }
20244
20245 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20246 PyObject *resultobj = 0;
20247 wxPNGHandler *result = 0 ;
20248
20249 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (wxPNGHandler *)new wxPNGHandler();
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20257 return resultobj;
20258 fail:
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20264 PyObject *obj;
20265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20266 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20267 return SWIG_Py_Void();
20268 }
20269
20270 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20271 return SWIG_Python_InitShadowInstance(args);
20272 }
20273
20274 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20275 PyObject *resultobj = 0;
20276 wxGIFHandler *result = 0 ;
20277
20278 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (wxGIFHandler *)new wxGIFHandler();
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20286 return resultobj;
20287 fail:
20288 return NULL;
20289 }
20290
20291
20292 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20293 PyObject *obj;
20294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20295 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20296 return SWIG_Py_Void();
20297 }
20298
20299 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 return SWIG_Python_InitShadowInstance(args);
20301 }
20302
20303 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *resultobj = 0;
20305 wxPCXHandler *result = 0 ;
20306
20307 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (wxPCXHandler *)new wxPCXHandler();
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20315 return resultobj;
20316 fail:
20317 return NULL;
20318 }
20319
20320
20321 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20322 PyObject *obj;
20323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20324 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20325 return SWIG_Py_Void();
20326 }
20327
20328 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 return SWIG_Python_InitShadowInstance(args);
20330 }
20331
20332 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 PyObject *resultobj = 0;
20334 wxJPEGHandler *result = 0 ;
20335
20336 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20337 {
20338 PyThreadState* __tstate = wxPyBeginAllowThreads();
20339 result = (wxJPEGHandler *)new wxJPEGHandler();
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20351 PyObject *obj;
20352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20353 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20354 return SWIG_Py_Void();
20355 }
20356
20357 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 return SWIG_Python_InitShadowInstance(args);
20359 }
20360
20361 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20362 PyObject *resultobj = 0;
20363 wxPNMHandler *result = 0 ;
20364
20365 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = (wxPNMHandler *)new wxPNMHandler();
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20373 return resultobj;
20374 fail:
20375 return NULL;
20376 }
20377
20378
20379 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20380 PyObject *obj;
20381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20382 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20383 return SWIG_Py_Void();
20384 }
20385
20386 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 return SWIG_Python_InitShadowInstance(args);
20388 }
20389
20390 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20391 PyObject *resultobj = 0;
20392 wxXPMHandler *result = 0 ;
20393
20394 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 result = (wxXPMHandler *)new wxXPMHandler();
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20409 PyObject *obj;
20410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20411 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20412 return SWIG_Py_Void();
20413 }
20414
20415 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 return SWIG_Python_InitShadowInstance(args);
20417 }
20418
20419 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *resultobj = 0;
20421 wxTIFFHandler *result = 0 ;
20422
20423 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20424 {
20425 PyThreadState* __tstate = wxPyBeginAllowThreads();
20426 result = (wxTIFFHandler *)new wxTIFFHandler();
20427 wxPyEndAllowThreads(__tstate);
20428 if (PyErr_Occurred()) SWIG_fail;
20429 }
20430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20431 return resultobj;
20432 fail:
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20438 PyObject *obj;
20439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20440 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20441 return SWIG_Py_Void();
20442 }
20443
20444 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20445 return SWIG_Python_InitShadowInstance(args);
20446 }
20447
20448 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20449 PyObject *resultobj = 0;
20450 wxTGAHandler *result = 0 ;
20451
20452 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (wxTGAHandler *)new wxTGAHandler();
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20467 PyObject *obj;
20468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20469 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20470 return SWIG_Py_Void();
20471 }
20472
20473 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20474 return SWIG_Python_InitShadowInstance(args);
20475 }
20476
20477 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20478 PyObject *resultobj = 0;
20479 wxImage *arg1 = 0 ;
20480 wxImage *arg2 = 0 ;
20481 int arg3 = (int) 236 ;
20482 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20483 bool result;
20484 void *argp1 = 0 ;
20485 int res1 = 0 ;
20486 void *argp2 = 0 ;
20487 int res2 = 0 ;
20488 int val3 ;
20489 int ecode3 = 0 ;
20490 int val4 ;
20491 int ecode4 = 0 ;
20492 PyObject * obj0 = 0 ;
20493 PyObject * obj1 = 0 ;
20494 PyObject * obj2 = 0 ;
20495 PyObject * obj3 = 0 ;
20496 char * kwnames[] = {
20497 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20498 };
20499
20500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20501 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20502 if (!SWIG_IsOK(res1)) {
20503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20504 }
20505 if (!argp1) {
20506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20507 }
20508 arg1 = reinterpret_cast< wxImage * >(argp1);
20509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20510 if (!SWIG_IsOK(res2)) {
20511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20512 }
20513 if (!argp2) {
20514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20515 }
20516 arg2 = reinterpret_cast< wxImage * >(argp2);
20517 if (obj2) {
20518 ecode3 = SWIG_AsVal_int(obj2, &val3);
20519 if (!SWIG_IsOK(ecode3)) {
20520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20521 }
20522 arg3 = static_cast< int >(val3);
20523 }
20524 if (obj3) {
20525 ecode4 = SWIG_AsVal_int(obj3, &val4);
20526 if (!SWIG_IsOK(ecode4)) {
20527 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20528 }
20529 arg4 = static_cast< int >(val4);
20530 }
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 {
20538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20539 }
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20547 PyObject *obj;
20548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20549 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20550 return SWIG_Py_Void();
20551 }
20552
20553 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20554 PyObject *resultobj = 0;
20555 wxEvtHandler *result = 0 ;
20556
20557 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20558 {
20559 PyThreadState* __tstate = wxPyBeginAllowThreads();
20560 result = (wxEvtHandler *)new wxEvtHandler();
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20572 PyObject *resultobj = 0;
20573 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20574 wxEvtHandler *result = 0 ;
20575 void *argp1 = 0 ;
20576 int res1 = 0 ;
20577 PyObject *swig_obj[1] ;
20578
20579 if (!args) SWIG_fail;
20580 swig_obj[0] = args;
20581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20584 }
20585 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = wxPyMake_wxObject(result, 0);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *resultobj = 0;
20603 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20604 wxEvtHandler *result = 0 ;
20605 void *argp1 = 0 ;
20606 int res1 = 0 ;
20607 PyObject *swig_obj[1] ;
20608
20609 if (!args) SWIG_fail;
20610 swig_obj[0] = args;
20611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20612 if (!SWIG_IsOK(res1)) {
20613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20614 }
20615 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 {
20623 resultobj = wxPyMake_wxObject(result, 0);
20624 }
20625 return resultobj;
20626 fail:
20627 return NULL;
20628 }
20629
20630
20631 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20632 PyObject *resultobj = 0;
20633 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20634 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20635 void *argp1 = 0 ;
20636 int res1 = 0 ;
20637 void *argp2 = 0 ;
20638 int res2 = 0 ;
20639 PyObject * obj0 = 0 ;
20640 PyObject * obj1 = 0 ;
20641 char * kwnames[] = {
20642 (char *) "self",(char *) "handler", NULL
20643 };
20644
20645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20649 }
20650 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20652 if (!SWIG_IsOK(res2)) {
20653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20654 }
20655 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 (arg1)->SetNextHandler(arg2);
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 resultobj = SWIG_Py_Void();
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj = 0;
20671 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20672 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20673 void *argp1 = 0 ;
20674 int res1 = 0 ;
20675 void *argp2 = 0 ;
20676 int res2 = 0 ;
20677 PyObject * obj0 = 0 ;
20678 PyObject * obj1 = 0 ;
20679 char * kwnames[] = {
20680 (char *) "self",(char *) "handler", NULL
20681 };
20682
20683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20685 if (!SWIG_IsOK(res1)) {
20686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20687 }
20688 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20690 if (!SWIG_IsOK(res2)) {
20691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20692 }
20693 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 (arg1)->SetPreviousHandler(arg2);
20697 wxPyEndAllowThreads(__tstate);
20698 if (PyErr_Occurred()) SWIG_fail;
20699 }
20700 resultobj = SWIG_Py_Void();
20701 return resultobj;
20702 fail:
20703 return NULL;
20704 }
20705
20706
20707 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20708 PyObject *resultobj = 0;
20709 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20710 bool result;
20711 void *argp1 = 0 ;
20712 int res1 = 0 ;
20713 PyObject *swig_obj[1] ;
20714
20715 if (!args) SWIG_fail;
20716 swig_obj[0] = args;
20717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20718 if (!SWIG_IsOK(res1)) {
20719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20720 }
20721 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20722 {
20723 PyThreadState* __tstate = wxPyBeginAllowThreads();
20724 result = (bool)(arg1)->GetEvtHandlerEnabled();
20725 wxPyEndAllowThreads(__tstate);
20726 if (PyErr_Occurred()) SWIG_fail;
20727 }
20728 {
20729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20730 }
20731 return resultobj;
20732 fail:
20733 return NULL;
20734 }
20735
20736
20737 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20738 PyObject *resultobj = 0;
20739 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20740 bool arg2 ;
20741 void *argp1 = 0 ;
20742 int res1 = 0 ;
20743 bool val2 ;
20744 int ecode2 = 0 ;
20745 PyObject * obj0 = 0 ;
20746 PyObject * obj1 = 0 ;
20747 char * kwnames[] = {
20748 (char *) "self",(char *) "enabled", NULL
20749 };
20750
20751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20755 }
20756 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20758 if (!SWIG_IsOK(ecode2)) {
20759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20760 }
20761 arg2 = static_cast< bool >(val2);
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 (arg1)->SetEvtHandlerEnabled(arg2);
20765 wxPyEndAllowThreads(__tstate);
20766 if (PyErr_Occurred()) SWIG_fail;
20767 }
20768 resultobj = SWIG_Py_Void();
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20776 PyObject *resultobj = 0;
20777 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20778 wxEvent *arg2 = 0 ;
20779 bool result;
20780 void *argp1 = 0 ;
20781 int res1 = 0 ;
20782 void *argp2 = 0 ;
20783 int res2 = 0 ;
20784 PyObject * obj0 = 0 ;
20785 PyObject * obj1 = 0 ;
20786 char * kwnames[] = {
20787 (char *) "self",(char *) "event", NULL
20788 };
20789
20790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20792 if (!SWIG_IsOK(res1)) {
20793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20794 }
20795 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20797 if (!SWIG_IsOK(res2)) {
20798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20799 }
20800 if (!argp2) {
20801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20802 }
20803 arg2 = reinterpret_cast< wxEvent * >(argp2);
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (bool)(arg1)->ProcessEvent(*arg2);
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 {
20811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20812 }
20813 return resultobj;
20814 fail:
20815 return NULL;
20816 }
20817
20818
20819 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20820 PyObject *resultobj = 0;
20821 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20822 wxEvent *arg2 = 0 ;
20823 void *argp1 = 0 ;
20824 int res1 = 0 ;
20825 void *argp2 = 0 ;
20826 int res2 = 0 ;
20827 PyObject * obj0 = 0 ;
20828 PyObject * obj1 = 0 ;
20829 char * kwnames[] = {
20830 (char *) "self",(char *) "event", NULL
20831 };
20832
20833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20837 }
20838 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20840 if (!SWIG_IsOK(res2)) {
20841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20842 }
20843 if (!argp2) {
20844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20845 }
20846 arg2 = reinterpret_cast< wxEvent * >(argp2);
20847 {
20848 PyThreadState* __tstate = wxPyBeginAllowThreads();
20849 (arg1)->AddPendingEvent(*arg2);
20850 wxPyEndAllowThreads(__tstate);
20851 if (PyErr_Occurred()) SWIG_fail;
20852 }
20853 resultobj = SWIG_Py_Void();
20854 return resultobj;
20855 fail:
20856 return NULL;
20857 }
20858
20859
20860 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20861 PyObject *resultobj = 0;
20862 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20863 void *argp1 = 0 ;
20864 int res1 = 0 ;
20865 PyObject *swig_obj[1] ;
20866
20867 if (!args) SWIG_fail;
20868 swig_obj[0] = args;
20869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20870 if (!SWIG_IsOK(res1)) {
20871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20872 }
20873 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 (arg1)->ProcessPendingEvents();
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 resultobj = SWIG_Py_Void();
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20888 PyObject *resultobj = 0;
20889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20890 int arg2 ;
20891 int arg3 ;
20892 int arg4 ;
20893 PyObject *arg5 = (PyObject *) 0 ;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 int val2 ;
20897 int ecode2 = 0 ;
20898 int val3 ;
20899 int ecode3 = 0 ;
20900 int val4 ;
20901 int ecode4 = 0 ;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 PyObject * obj2 = 0 ;
20905 PyObject * obj3 = 0 ;
20906 PyObject * obj4 = 0 ;
20907 char * kwnames[] = {
20908 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20909 };
20910
20911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20913 if (!SWIG_IsOK(res1)) {
20914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20915 }
20916 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20917 ecode2 = SWIG_AsVal_int(obj1, &val2);
20918 if (!SWIG_IsOK(ecode2)) {
20919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20920 }
20921 arg2 = static_cast< int >(val2);
20922 ecode3 = SWIG_AsVal_int(obj2, &val3);
20923 if (!SWIG_IsOK(ecode3)) {
20924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20925 }
20926 arg3 = static_cast< int >(val3);
20927 ecode4 = SWIG_AsVal_int(obj3, &val4);
20928 if (!SWIG_IsOK(ecode4)) {
20929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20930 }
20931 arg4 = static_cast< int >(val4);
20932 arg5 = obj4;
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 resultobj = SWIG_Py_Void();
20940 return resultobj;
20941 fail:
20942 return NULL;
20943 }
20944
20945
20946 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20947 PyObject *resultobj = 0;
20948 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20949 int arg2 ;
20950 int arg3 = (int) -1 ;
20951 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20952 bool result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 int val2 ;
20956 int ecode2 = 0 ;
20957 int val3 ;
20958 int ecode3 = 0 ;
20959 int val4 ;
20960 int ecode4 = 0 ;
20961 PyObject * obj0 = 0 ;
20962 PyObject * obj1 = 0 ;
20963 PyObject * obj2 = 0 ;
20964 PyObject * obj3 = 0 ;
20965 char * kwnames[] = {
20966 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20967 };
20968
20969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20971 if (!SWIG_IsOK(res1)) {
20972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20973 }
20974 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20975 ecode2 = SWIG_AsVal_int(obj1, &val2);
20976 if (!SWIG_IsOK(ecode2)) {
20977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20978 }
20979 arg2 = static_cast< int >(val2);
20980 if (obj2) {
20981 ecode3 = SWIG_AsVal_int(obj2, &val3);
20982 if (!SWIG_IsOK(ecode3)) {
20983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20984 }
20985 arg3 = static_cast< int >(val3);
20986 }
20987 if (obj3) {
20988 ecode4 = SWIG_AsVal_int(obj3, &val4);
20989 if (!SWIG_IsOK(ecode4)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20991 }
20992 arg4 = static_cast< wxEventType >(val4);
20993 }
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 {
21001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21002 }
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj = 0;
21011 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21012 PyObject *arg2 = (PyObject *) 0 ;
21013 bool arg3 = (bool) true ;
21014 void *argp1 = 0 ;
21015 int res1 = 0 ;
21016 bool val3 ;
21017 int ecode3 = 0 ;
21018 PyObject * obj0 = 0 ;
21019 PyObject * obj1 = 0 ;
21020 PyObject * obj2 = 0 ;
21021 char * kwnames[] = {
21022 (char *) "self",(char *) "_self",(char *) "incref", NULL
21023 };
21024
21025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21027 if (!SWIG_IsOK(res1)) {
21028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21029 }
21030 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21031 arg2 = obj1;
21032 if (obj2) {
21033 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21034 if (!SWIG_IsOK(ecode3)) {
21035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21036 }
21037 arg3 = static_cast< bool >(val3);
21038 }
21039 {
21040 PyThreadState* __tstate = wxPyBeginAllowThreads();
21041 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 resultobj = SWIG_Py_Void();
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 PyObject *obj;
21054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21055 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21056 return SWIG_Py_Void();
21057 }
21058
21059 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21060 return SWIG_Python_InitShadowInstance(args);
21061 }
21062
21063 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21064 PyObject *resultobj = 0;
21065 wxEventType result;
21066
21067 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = (wxEventType)wxNewEventType();
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 resultobj = SWIG_From_int(static_cast< int >(result));
21075 return resultobj;
21076 fail:
21077 return NULL;
21078 }
21079
21080
21081 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 PyObject *resultobj = 0;
21083 wxEvent *arg1 = (wxEvent *) 0 ;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 PyObject *swig_obj[1] ;
21087
21088 if (!args) SWIG_fail;
21089 swig_obj[0] = args;
21090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21091 if (!SWIG_IsOK(res1)) {
21092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21093 }
21094 arg1 = reinterpret_cast< wxEvent * >(argp1);
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 delete arg1;
21098
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 resultobj = SWIG_Py_Void();
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj = 0;
21111 wxEvent *arg1 = (wxEvent *) 0 ;
21112 wxEventType arg2 ;
21113 void *argp1 = 0 ;
21114 int res1 = 0 ;
21115 int val2 ;
21116 int ecode2 = 0 ;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char * kwnames[] = {
21120 (char *) "self",(char *) "typ", NULL
21121 };
21122
21123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21125 if (!SWIG_IsOK(res1)) {
21126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21127 }
21128 arg1 = reinterpret_cast< wxEvent * >(argp1);
21129 ecode2 = SWIG_AsVal_int(obj1, &val2);
21130 if (!SWIG_IsOK(ecode2)) {
21131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21132 }
21133 arg2 = static_cast< wxEventType >(val2);
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 (arg1)->SetEventType(arg2);
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_Py_Void();
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148 PyObject *resultobj = 0;
21149 wxEvent *arg1 = (wxEvent *) 0 ;
21150 wxEventType result;
21151 void *argp1 = 0 ;
21152 int res1 = 0 ;
21153 PyObject *swig_obj[1] ;
21154
21155 if (!args) SWIG_fail;
21156 swig_obj[0] = args;
21157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21160 }
21161 arg1 = reinterpret_cast< wxEvent * >(argp1);
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 resultobj = SWIG_From_int(static_cast< int >(result));
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxEvent *arg1 = (wxEvent *) 0 ;
21178 wxObject *result = 0 ;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21188 }
21189 arg1 = reinterpret_cast< wxEvent * >(argp1);
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 {
21197 resultobj = wxPyMake_wxObject(result, (bool)0);
21198 }
21199 return resultobj;
21200 fail:
21201 return NULL;
21202 }
21203
21204
21205 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21206 PyObject *resultobj = 0;
21207 wxEvent *arg1 = (wxEvent *) 0 ;
21208 wxObject *arg2 = (wxObject *) 0 ;
21209 void *argp1 = 0 ;
21210 int res1 = 0 ;
21211 void *argp2 = 0 ;
21212 int res2 = 0 ;
21213 PyObject * obj0 = 0 ;
21214 PyObject * obj1 = 0 ;
21215 char * kwnames[] = {
21216 (char *) "self",(char *) "obj", NULL
21217 };
21218
21219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21221 if (!SWIG_IsOK(res1)) {
21222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21223 }
21224 arg1 = reinterpret_cast< wxEvent * >(argp1);
21225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21226 if (!SWIG_IsOK(res2)) {
21227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21228 }
21229 arg2 = reinterpret_cast< wxObject * >(argp2);
21230 {
21231 PyThreadState* __tstate = wxPyBeginAllowThreads();
21232 (arg1)->SetEventObject(arg2);
21233 wxPyEndAllowThreads(__tstate);
21234 if (PyErr_Occurred()) SWIG_fail;
21235 }
21236 resultobj = SWIG_Py_Void();
21237 return resultobj;
21238 fail:
21239 return NULL;
21240 }
21241
21242
21243 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21244 PyObject *resultobj = 0;
21245 wxEvent *arg1 = (wxEvent *) 0 ;
21246 long result;
21247 void *argp1 = 0 ;
21248 int res1 = 0 ;
21249 PyObject *swig_obj[1] ;
21250
21251 if (!args) SWIG_fail;
21252 swig_obj[0] = args;
21253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21256 }
21257 arg1 = reinterpret_cast< wxEvent * >(argp1);
21258 {
21259 PyThreadState* __tstate = wxPyBeginAllowThreads();
21260 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21261 wxPyEndAllowThreads(__tstate);
21262 if (PyErr_Occurred()) SWIG_fail;
21263 }
21264 resultobj = SWIG_From_long(static_cast< long >(result));
21265 return resultobj;
21266 fail:
21267 return NULL;
21268 }
21269
21270
21271 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21272 PyObject *resultobj = 0;
21273 wxEvent *arg1 = (wxEvent *) 0 ;
21274 long arg2 = (long) 0 ;
21275 void *argp1 = 0 ;
21276 int res1 = 0 ;
21277 long val2 ;
21278 int ecode2 = 0 ;
21279 PyObject * obj0 = 0 ;
21280 PyObject * obj1 = 0 ;
21281 char * kwnames[] = {
21282 (char *) "self",(char *) "ts", NULL
21283 };
21284
21285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21287 if (!SWIG_IsOK(res1)) {
21288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21289 }
21290 arg1 = reinterpret_cast< wxEvent * >(argp1);
21291 if (obj1) {
21292 ecode2 = SWIG_AsVal_long(obj1, &val2);
21293 if (!SWIG_IsOK(ecode2)) {
21294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21295 }
21296 arg2 = static_cast< long >(val2);
21297 }
21298 {
21299 PyThreadState* __tstate = wxPyBeginAllowThreads();
21300 (arg1)->SetTimestamp(arg2);
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 resultobj = SWIG_Py_Void();
21305 return resultobj;
21306 fail:
21307 return NULL;
21308 }
21309
21310
21311 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21312 PyObject *resultobj = 0;
21313 wxEvent *arg1 = (wxEvent *) 0 ;
21314 int result;
21315 void *argp1 = 0 ;
21316 int res1 = 0 ;
21317 PyObject *swig_obj[1] ;
21318
21319 if (!args) SWIG_fail;
21320 swig_obj[0] = args;
21321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21322 if (!SWIG_IsOK(res1)) {
21323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21324 }
21325 arg1 = reinterpret_cast< wxEvent * >(argp1);
21326 {
21327 PyThreadState* __tstate = wxPyBeginAllowThreads();
21328 result = (int)((wxEvent const *)arg1)->GetId();
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 resultobj = SWIG_From_int(static_cast< int >(result));
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj = 0;
21341 wxEvent *arg1 = (wxEvent *) 0 ;
21342 int arg2 ;
21343 void *argp1 = 0 ;
21344 int res1 = 0 ;
21345 int val2 ;
21346 int ecode2 = 0 ;
21347 PyObject * obj0 = 0 ;
21348 PyObject * obj1 = 0 ;
21349 char * kwnames[] = {
21350 (char *) "self",(char *) "Id", NULL
21351 };
21352
21353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21355 if (!SWIG_IsOK(res1)) {
21356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21357 }
21358 arg1 = reinterpret_cast< wxEvent * >(argp1);
21359 ecode2 = SWIG_AsVal_int(obj1, &val2);
21360 if (!SWIG_IsOK(ecode2)) {
21361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21362 }
21363 arg2 = static_cast< int >(val2);
21364 {
21365 PyThreadState* __tstate = wxPyBeginAllowThreads();
21366 (arg1)->SetId(arg2);
21367 wxPyEndAllowThreads(__tstate);
21368 if (PyErr_Occurred()) SWIG_fail;
21369 }
21370 resultobj = SWIG_Py_Void();
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxEvent *arg1 = (wxEvent *) 0 ;
21380 bool result;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21390 }
21391 arg1 = reinterpret_cast< wxEvent * >(argp1);
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21395 wxPyEndAllowThreads(__tstate);
21396 if (PyErr_Occurred()) SWIG_fail;
21397 }
21398 {
21399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21400 }
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21408 PyObject *resultobj = 0;
21409 wxEvent *arg1 = (wxEvent *) 0 ;
21410 bool arg2 = (bool) true ;
21411 void *argp1 = 0 ;
21412 int res1 = 0 ;
21413 bool val2 ;
21414 int ecode2 = 0 ;
21415 PyObject * obj0 = 0 ;
21416 PyObject * obj1 = 0 ;
21417 char * kwnames[] = {
21418 (char *) "self",(char *) "skip", NULL
21419 };
21420
21421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21423 if (!SWIG_IsOK(res1)) {
21424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21425 }
21426 arg1 = reinterpret_cast< wxEvent * >(argp1);
21427 if (obj1) {
21428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21429 if (!SWIG_IsOK(ecode2)) {
21430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21431 }
21432 arg2 = static_cast< bool >(val2);
21433 }
21434 {
21435 PyThreadState* __tstate = wxPyBeginAllowThreads();
21436 (arg1)->Skip(arg2);
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxEvent *arg1 = (wxEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21460 }
21461 arg1 = reinterpret_cast< wxEvent * >(argp1);
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 {
21469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21470 }
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21478 PyObject *resultobj = 0;
21479 wxEvent *arg1 = (wxEvent *) 0 ;
21480 bool result;
21481 void *argp1 = 0 ;
21482 int res1 = 0 ;
21483 PyObject *swig_obj[1] ;
21484
21485 if (!args) SWIG_fail;
21486 swig_obj[0] = args;
21487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21488 if (!SWIG_IsOK(res1)) {
21489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21490 }
21491 arg1 = reinterpret_cast< wxEvent * >(argp1);
21492 {
21493 PyThreadState* __tstate = wxPyBeginAllowThreads();
21494 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 {
21499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21500 }
21501 return resultobj;
21502 fail:
21503 return NULL;
21504 }
21505
21506
21507 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21508 PyObject *resultobj = 0;
21509 wxEvent *arg1 = (wxEvent *) 0 ;
21510 int result;
21511 void *argp1 = 0 ;
21512 int res1 = 0 ;
21513 PyObject *swig_obj[1] ;
21514
21515 if (!args) SWIG_fail;
21516 swig_obj[0] = args;
21517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21518 if (!SWIG_IsOK(res1)) {
21519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21520 }
21521 arg1 = reinterpret_cast< wxEvent * >(argp1);
21522 {
21523 PyThreadState* __tstate = wxPyBeginAllowThreads();
21524 result = (int)(arg1)->StopPropagation();
21525 wxPyEndAllowThreads(__tstate);
21526 if (PyErr_Occurred()) SWIG_fail;
21527 }
21528 resultobj = SWIG_From_int(static_cast< int >(result));
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21536 PyObject *resultobj = 0;
21537 wxEvent *arg1 = (wxEvent *) 0 ;
21538 int arg2 ;
21539 void *argp1 = 0 ;
21540 int res1 = 0 ;
21541 int val2 ;
21542 int ecode2 = 0 ;
21543 PyObject * obj0 = 0 ;
21544 PyObject * obj1 = 0 ;
21545 char * kwnames[] = {
21546 (char *) "self",(char *) "propagationLevel", NULL
21547 };
21548
21549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21551 if (!SWIG_IsOK(res1)) {
21552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21553 }
21554 arg1 = reinterpret_cast< wxEvent * >(argp1);
21555 ecode2 = SWIG_AsVal_int(obj1, &val2);
21556 if (!SWIG_IsOK(ecode2)) {
21557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21558 }
21559 arg2 = static_cast< int >(val2);
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 (arg1)->ResumePropagation(arg2);
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_Py_Void();
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxEvent *arg1 = (wxEvent *) 0 ;
21576 wxEvent *result = 0 ;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21586 }
21587 arg1 = reinterpret_cast< wxEvent * >(argp1);
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (wxEvent *)(arg1)->Clone();
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21602 PyObject *obj;
21603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21604 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21605 return SWIG_Py_Void();
21606 }
21607
21608 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21609 PyObject *resultobj = 0;
21610 wxEvent *arg1 = 0 ;
21611 wxPropagationDisabler *result = 0 ;
21612 void *argp1 = 0 ;
21613 int res1 = 0 ;
21614 PyObject * obj0 = 0 ;
21615 char * kwnames[] = {
21616 (char *) "event", NULL
21617 };
21618
21619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21620 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21621 if (!SWIG_IsOK(res1)) {
21622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21623 }
21624 if (!argp1) {
21625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21626 }
21627 arg1 = reinterpret_cast< wxEvent * >(argp1);
21628 {
21629 PyThreadState* __tstate = wxPyBeginAllowThreads();
21630 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21635 return resultobj;
21636 fail:
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 PyObject *resultobj = 0;
21643 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21644 void *argp1 = 0 ;
21645 int res1 = 0 ;
21646 PyObject *swig_obj[1] ;
21647
21648 if (!args) SWIG_fail;
21649 swig_obj[0] = args;
21650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21651 if (!SWIG_IsOK(res1)) {
21652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21653 }
21654 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21655 {
21656 PyThreadState* __tstate = wxPyBeginAllowThreads();
21657 delete arg1;
21658
21659 wxPyEndAllowThreads(__tstate);
21660 if (PyErr_Occurred()) SWIG_fail;
21661 }
21662 resultobj = SWIG_Py_Void();
21663 return resultobj;
21664 fail:
21665 return NULL;
21666 }
21667
21668
21669 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21670 PyObject *obj;
21671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21672 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21673 return SWIG_Py_Void();
21674 }
21675
21676 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21677 return SWIG_Python_InitShadowInstance(args);
21678 }
21679
21680 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj = 0;
21682 wxEvent *arg1 = 0 ;
21683 wxPropagateOnce *result = 0 ;
21684 void *argp1 = 0 ;
21685 int res1 = 0 ;
21686 PyObject * obj0 = 0 ;
21687 char * kwnames[] = {
21688 (char *) "event", NULL
21689 };
21690
21691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21692 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21693 if (!SWIG_IsOK(res1)) {
21694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21695 }
21696 if (!argp1) {
21697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21698 }
21699 arg1 = reinterpret_cast< wxEvent * >(argp1);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21714 PyObject *resultobj = 0;
21715 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21716 void *argp1 = 0 ;
21717 int res1 = 0 ;
21718 PyObject *swig_obj[1] ;
21719
21720 if (!args) SWIG_fail;
21721 swig_obj[0] = args;
21722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21723 if (!SWIG_IsOK(res1)) {
21724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21725 }
21726 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 delete arg1;
21730
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 resultobj = SWIG_Py_Void();
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *obj;
21743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21745 return SWIG_Py_Void();
21746 }
21747
21748 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 return SWIG_Python_InitShadowInstance(args);
21750 }
21751
21752 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj = 0;
21754 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21755 int arg2 = (int) 0 ;
21756 wxCommandEvent *result = 0 ;
21757 int val1 ;
21758 int ecode1 = 0 ;
21759 int val2 ;
21760 int ecode2 = 0 ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char * kwnames[] = {
21764 (char *) "commandType",(char *) "winid", NULL
21765 };
21766
21767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21768 if (obj0) {
21769 ecode1 = SWIG_AsVal_int(obj0, &val1);
21770 if (!SWIG_IsOK(ecode1)) {
21771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21772 }
21773 arg1 = static_cast< wxEventType >(val1);
21774 }
21775 if (obj1) {
21776 ecode2 = SWIG_AsVal_int(obj1, &val2);
21777 if (!SWIG_IsOK(ecode2)) {
21778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21779 }
21780 arg2 = static_cast< int >(val2);
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21796 PyObject *resultobj = 0;
21797 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21798 int result;
21799 void *argp1 = 0 ;
21800 int res1 = 0 ;
21801 PyObject *swig_obj[1] ;
21802
21803 if (!args) SWIG_fail;
21804 swig_obj[0] = args;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21808 }
21809 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 resultobj = SWIG_From_int(static_cast< int >(result));
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = 0;
21825 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21826 wxString *arg2 = 0 ;
21827 void *argp1 = 0 ;
21828 int res1 = 0 ;
21829 bool temp2 = false ;
21830 PyObject * obj0 = 0 ;
21831 PyObject * obj1 = 0 ;
21832 char * kwnames[] = {
21833 (char *) "self",(char *) "s", NULL
21834 };
21835
21836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21838 if (!SWIG_IsOK(res1)) {
21839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21840 }
21841 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21842 {
21843 arg2 = wxString_in_helper(obj1);
21844 if (arg2 == NULL) SWIG_fail;
21845 temp2 = true;
21846 }
21847 {
21848 PyThreadState* __tstate = wxPyBeginAllowThreads();
21849 (arg1)->SetString((wxString const &)*arg2);
21850 wxPyEndAllowThreads(__tstate);
21851 if (PyErr_Occurred()) SWIG_fail;
21852 }
21853 resultobj = SWIG_Py_Void();
21854 {
21855 if (temp2)
21856 delete arg2;
21857 }
21858 return resultobj;
21859 fail:
21860 {
21861 if (temp2)
21862 delete arg2;
21863 }
21864 return NULL;
21865 }
21866
21867
21868 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21869 PyObject *resultobj = 0;
21870 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21871 wxString result;
21872 void *argp1 = 0 ;
21873 int res1 = 0 ;
21874 PyObject *swig_obj[1] ;
21875
21876 if (!args) SWIG_fail;
21877 swig_obj[0] = args;
21878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21881 }
21882 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = ((wxCommandEvent const *)arg1)->GetString();
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 #if wxUSE_UNICODE
21891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21892 #else
21893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21894 #endif
21895 }
21896 return resultobj;
21897 fail:
21898 return NULL;
21899 }
21900
21901
21902 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21903 PyObject *resultobj = 0;
21904 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21905 bool result;
21906 void *argp1 = 0 ;
21907 int res1 = 0 ;
21908 PyObject *swig_obj[1] ;
21909
21910 if (!args) SWIG_fail;
21911 swig_obj[0] = args;
21912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21913 if (!SWIG_IsOK(res1)) {
21914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21915 }
21916 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21920 wxPyEndAllowThreads(__tstate);
21921 if (PyErr_Occurred()) SWIG_fail;
21922 }
21923 {
21924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21925 }
21926 return resultobj;
21927 fail:
21928 return NULL;
21929 }
21930
21931
21932 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21933 PyObject *resultobj = 0;
21934 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21935 bool result;
21936 void *argp1 = 0 ;
21937 int res1 = 0 ;
21938 PyObject *swig_obj[1] ;
21939
21940 if (!args) SWIG_fail;
21941 swig_obj[0] = args;
21942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21943 if (!SWIG_IsOK(res1)) {
21944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21945 }
21946 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21950 wxPyEndAllowThreads(__tstate);
21951 if (PyErr_Occurred()) SWIG_fail;
21952 }
21953 {
21954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21955 }
21956 return resultobj;
21957 fail:
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21965 long arg2 ;
21966 void *argp1 = 0 ;
21967 int res1 = 0 ;
21968 long val2 ;
21969 int ecode2 = 0 ;
21970 PyObject * obj0 = 0 ;
21971 PyObject * obj1 = 0 ;
21972 char * kwnames[] = {
21973 (char *) "self",(char *) "extraLong", NULL
21974 };
21975
21976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21978 if (!SWIG_IsOK(res1)) {
21979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21980 }
21981 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21982 ecode2 = SWIG_AsVal_long(obj1, &val2);
21983 if (!SWIG_IsOK(ecode2)) {
21984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21985 }
21986 arg2 = static_cast< long >(val2);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 (arg1)->SetExtraLong(arg2);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 resultobj = SWIG_Py_Void();
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22003 long result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 PyObject *swig_obj[1] ;
22007
22008 if (!args) SWIG_fail;
22009 swig_obj[0] = args;
22010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22011 if (!SWIG_IsOK(res1)) {
22012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22013 }
22014 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22018 wxPyEndAllowThreads(__tstate);
22019 if (PyErr_Occurred()) SWIG_fail;
22020 }
22021 resultobj = SWIG_From_long(static_cast< long >(result));
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22029 PyObject *resultobj = 0;
22030 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22031 int arg2 ;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 int val2 ;
22035 int ecode2 = 0 ;
22036 PyObject * obj0 = 0 ;
22037 PyObject * obj1 = 0 ;
22038 char * kwnames[] = {
22039 (char *) "self",(char *) "i", NULL
22040 };
22041
22042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22044 if (!SWIG_IsOK(res1)) {
22045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22046 }
22047 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22048 ecode2 = SWIG_AsVal_int(obj1, &val2);
22049 if (!SWIG_IsOK(ecode2)) {
22050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22051 }
22052 arg2 = static_cast< int >(val2);
22053 {
22054 PyThreadState* __tstate = wxPyBeginAllowThreads();
22055 (arg1)->SetInt(arg2);
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 resultobj = SWIG_Py_Void();
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22069 int result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 resultobj = SWIG_From_int(static_cast< int >(result));
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22095 PyObject *resultobj = 0;
22096 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22097 PyObject *result = 0 ;
22098 void *argp1 = 0 ;
22099 int res1 = 0 ;
22100 PyObject *swig_obj[1] ;
22101
22102 if (!args) SWIG_fail;
22103 swig_obj[0] = args;
22104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22105 if (!SWIG_IsOK(res1)) {
22106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22107 }
22108 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22109 {
22110 PyThreadState* __tstate = wxPyBeginAllowThreads();
22111 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22112 wxPyEndAllowThreads(__tstate);
22113 if (PyErr_Occurred()) SWIG_fail;
22114 }
22115 resultobj = result;
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj = 0;
22124 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22125 PyObject *arg2 = (PyObject *) 0 ;
22126 void *argp1 = 0 ;
22127 int res1 = 0 ;
22128 PyObject * obj0 = 0 ;
22129 PyObject * obj1 = 0 ;
22130 char * kwnames[] = {
22131 (char *) "self",(char *) "clientData", NULL
22132 };
22133
22134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22136 if (!SWIG_IsOK(res1)) {
22137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22138 }
22139 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22140 arg2 = obj1;
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 wxCommandEvent_SetClientData(arg1,arg2);
22144 wxPyEndAllowThreads(__tstate);
22145 if (PyErr_Occurred()) SWIG_fail;
22146 }
22147 resultobj = SWIG_Py_Void();
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22155 PyObject *resultobj = 0;
22156 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22157 wxEvent *result = 0 ;
22158 void *argp1 = 0 ;
22159 int res1 = 0 ;
22160 PyObject *swig_obj[1] ;
22161
22162 if (!args) SWIG_fail;
22163 swig_obj[0] = args;
22164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22165 if (!SWIG_IsOK(res1)) {
22166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22167 }
22168 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22176 return resultobj;
22177 fail:
22178 return NULL;
22179 }
22180
22181
22182 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22183 PyObject *obj;
22184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22185 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22186 return SWIG_Py_Void();
22187 }
22188
22189 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 return SWIG_Python_InitShadowInstance(args);
22191 }
22192
22193 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj = 0;
22195 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22196 int arg2 = (int) 0 ;
22197 wxNotifyEvent *result = 0 ;
22198 int val1 ;
22199 int ecode1 = 0 ;
22200 int val2 ;
22201 int ecode2 = 0 ;
22202 PyObject * obj0 = 0 ;
22203 PyObject * obj1 = 0 ;
22204 char * kwnames[] = {
22205 (char *) "commandType",(char *) "winid", NULL
22206 };
22207
22208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22209 if (obj0) {
22210 ecode1 = SWIG_AsVal_int(obj0, &val1);
22211 if (!SWIG_IsOK(ecode1)) {
22212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22213 }
22214 arg1 = static_cast< wxEventType >(val1);
22215 }
22216 if (obj1) {
22217 ecode2 = SWIG_AsVal_int(obj1, &val2);
22218 if (!SWIG_IsOK(ecode2)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22220 }
22221 arg2 = static_cast< int >(val2);
22222 }
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
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_wxNotifyEvent, 0 | 0 );
22246 if (!SWIG_IsOK(res1)) {
22247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22248 }
22249 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 (arg1)->Veto();
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 resultobj = SWIG_Py_Void();
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22264 PyObject *resultobj = 0;
22265 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22266 void *argp1 = 0 ;
22267 int res1 = 0 ;
22268 PyObject *swig_obj[1] ;
22269
22270 if (!args) SWIG_fail;
22271 swig_obj[0] = args;
22272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22273 if (!SWIG_IsOK(res1)) {
22274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22275 }
22276 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 (arg1)->Allow();
22280 wxPyEndAllowThreads(__tstate);
22281 if (PyErr_Occurred()) SWIG_fail;
22282 }
22283 resultobj = SWIG_Py_Void();
22284 return resultobj;
22285 fail:
22286 return NULL;
22287 }
22288
22289
22290 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22291 PyObject *resultobj = 0;
22292 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22293 bool result;
22294 void *argp1 = 0 ;
22295 int res1 = 0 ;
22296 PyObject *swig_obj[1] ;
22297
22298 if (!args) SWIG_fail;
22299 swig_obj[0] = args;
22300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22303 }
22304 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 result = (bool)(arg1)->IsAllowed();
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 {
22312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22313 }
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321 PyObject *obj;
22322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22323 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22324 return SWIG_Py_Void();
22325 }
22326
22327 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22328 return SWIG_Python_InitShadowInstance(args);
22329 }
22330
22331 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22332 PyObject *resultobj = 0;
22333 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22334 int arg2 = (int) 0 ;
22335 int arg3 = (int) 0 ;
22336 int arg4 = (int) 0 ;
22337 wxScrollEvent *result = 0 ;
22338 int val1 ;
22339 int ecode1 = 0 ;
22340 int val2 ;
22341 int ecode2 = 0 ;
22342 int val3 ;
22343 int ecode3 = 0 ;
22344 int val4 ;
22345 int ecode4 = 0 ;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 PyObject * obj2 = 0 ;
22349 PyObject * obj3 = 0 ;
22350 char * kwnames[] = {
22351 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22352 };
22353
22354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22355 if (obj0) {
22356 ecode1 = SWIG_AsVal_int(obj0, &val1);
22357 if (!SWIG_IsOK(ecode1)) {
22358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22359 }
22360 arg1 = static_cast< wxEventType >(val1);
22361 }
22362 if (obj1) {
22363 ecode2 = SWIG_AsVal_int(obj1, &val2);
22364 if (!SWIG_IsOK(ecode2)) {
22365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22366 }
22367 arg2 = static_cast< int >(val2);
22368 }
22369 if (obj2) {
22370 ecode3 = SWIG_AsVal_int(obj2, &val3);
22371 if (!SWIG_IsOK(ecode3)) {
22372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22373 }
22374 arg3 = static_cast< int >(val3);
22375 }
22376 if (obj3) {
22377 ecode4 = SWIG_AsVal_int(obj3, &val4);
22378 if (!SWIG_IsOK(ecode4)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22380 }
22381 arg4 = static_cast< int >(val4);
22382 }
22383 {
22384 PyThreadState* __tstate = wxPyBeginAllowThreads();
22385 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22386 wxPyEndAllowThreads(__tstate);
22387 if (PyErr_Occurred()) SWIG_fail;
22388 }
22389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22397 PyObject *resultobj = 0;
22398 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22399 int 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_wxScrollEvent, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22409 }
22410 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 resultobj = SWIG_From_int(static_cast< int >(result));
22418 return resultobj;
22419 fail:
22420 return NULL;
22421 }
22422
22423
22424 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22425 PyObject *resultobj = 0;
22426 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22427 int result;
22428 void *argp1 = 0 ;
22429 int res1 = 0 ;
22430 PyObject *swig_obj[1] ;
22431
22432 if (!args) SWIG_fail;
22433 swig_obj[0] = args;
22434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22435 if (!SWIG_IsOK(res1)) {
22436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22437 }
22438 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_From_int(static_cast< int >(result));
22446 return resultobj;
22447 fail:
22448 return NULL;
22449 }
22450
22451
22452 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22453 PyObject *resultobj = 0;
22454 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22455 int arg2 ;
22456 void *argp1 = 0 ;
22457 int res1 = 0 ;
22458 int val2 ;
22459 int ecode2 = 0 ;
22460 PyObject * obj0 = 0 ;
22461 PyObject * obj1 = 0 ;
22462 char * kwnames[] = {
22463 (char *) "self",(char *) "orient", NULL
22464 };
22465
22466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22468 if (!SWIG_IsOK(res1)) {
22469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22470 }
22471 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22472 ecode2 = SWIG_AsVal_int(obj1, &val2);
22473 if (!SWIG_IsOK(ecode2)) {
22474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22475 }
22476 arg2 = static_cast< int >(val2);
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 (arg1)->SetOrientation(arg2);
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 resultobj = SWIG_Py_Void();
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22491 PyObject *resultobj = 0;
22492 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22493 int arg2 ;
22494 void *argp1 = 0 ;
22495 int res1 = 0 ;
22496 int val2 ;
22497 int ecode2 = 0 ;
22498 PyObject * obj0 = 0 ;
22499 PyObject * obj1 = 0 ;
22500 char * kwnames[] = {
22501 (char *) "self",(char *) "pos", NULL
22502 };
22503
22504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22508 }
22509 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22510 ecode2 = SWIG_AsVal_int(obj1, &val2);
22511 if (!SWIG_IsOK(ecode2)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22513 }
22514 arg2 = static_cast< int >(val2);
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 (arg1)->SetPosition(arg2);
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 resultobj = SWIG_Py_Void();
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22529 PyObject *obj;
22530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22531 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22532 return SWIG_Py_Void();
22533 }
22534
22535 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22536 return SWIG_Python_InitShadowInstance(args);
22537 }
22538
22539 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22540 PyObject *resultobj = 0;
22541 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22542 int arg2 = (int) 0 ;
22543 int arg3 = (int) 0 ;
22544 wxScrollWinEvent *result = 0 ;
22545 int val1 ;
22546 int ecode1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 int val3 ;
22550 int ecode3 = 0 ;
22551 PyObject * obj0 = 0 ;
22552 PyObject * obj1 = 0 ;
22553 PyObject * obj2 = 0 ;
22554 char * kwnames[] = {
22555 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22556 };
22557
22558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22559 if (obj0) {
22560 ecode1 = SWIG_AsVal_int(obj0, &val1);
22561 if (!SWIG_IsOK(ecode1)) {
22562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22563 }
22564 arg1 = static_cast< wxEventType >(val1);
22565 }
22566 if (obj1) {
22567 ecode2 = SWIG_AsVal_int(obj1, &val2);
22568 if (!SWIG_IsOK(ecode2)) {
22569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22570 }
22571 arg2 = static_cast< int >(val2);
22572 }
22573 if (obj2) {
22574 ecode3 = SWIG_AsVal_int(obj2, &val3);
22575 if (!SWIG_IsOK(ecode3)) {
22576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22577 }
22578 arg3 = static_cast< int >(val3);
22579 }
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22594 PyObject *resultobj = 0;
22595 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22596 int result;
22597 void *argp1 = 0 ;
22598 int res1 = 0 ;
22599 PyObject *swig_obj[1] ;
22600
22601 if (!args) SWIG_fail;
22602 swig_obj[0] = args;
22603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22604 if (!SWIG_IsOK(res1)) {
22605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22606 }
22607 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22608 {
22609 PyThreadState* __tstate = wxPyBeginAllowThreads();
22610 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 resultobj = SWIG_From_int(static_cast< int >(result));
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22622 PyObject *resultobj = 0;
22623 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22624 int result;
22625 void *argp1 = 0 ;
22626 int res1 = 0 ;
22627 PyObject *swig_obj[1] ;
22628
22629 if (!args) SWIG_fail;
22630 swig_obj[0] = args;
22631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22632 if (!SWIG_IsOK(res1)) {
22633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22634 }
22635 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22636 {
22637 PyThreadState* __tstate = wxPyBeginAllowThreads();
22638 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_From_int(static_cast< int >(result));
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj = 0;
22651 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22652 int arg2 ;
22653 void *argp1 = 0 ;
22654 int res1 = 0 ;
22655 int val2 ;
22656 int ecode2 = 0 ;
22657 PyObject * obj0 = 0 ;
22658 PyObject * obj1 = 0 ;
22659 char * kwnames[] = {
22660 (char *) "self",(char *) "orient", NULL
22661 };
22662
22663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22665 if (!SWIG_IsOK(res1)) {
22666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22667 }
22668 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22669 ecode2 = SWIG_AsVal_int(obj1, &val2);
22670 if (!SWIG_IsOK(ecode2)) {
22671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22672 }
22673 arg2 = static_cast< int >(val2);
22674 {
22675 PyThreadState* __tstate = wxPyBeginAllowThreads();
22676 (arg1)->SetOrientation(arg2);
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 resultobj = SWIG_Py_Void();
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj = 0;
22689 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22690 int arg2 ;
22691 void *argp1 = 0 ;
22692 int res1 = 0 ;
22693 int val2 ;
22694 int ecode2 = 0 ;
22695 PyObject * obj0 = 0 ;
22696 PyObject * obj1 = 0 ;
22697 char * kwnames[] = {
22698 (char *) "self",(char *) "pos", NULL
22699 };
22700
22701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22707 ecode2 = SWIG_AsVal_int(obj1, &val2);
22708 if (!SWIG_IsOK(ecode2)) {
22709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22710 }
22711 arg2 = static_cast< int >(val2);
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 (arg1)->SetPosition(arg2);
22715 wxPyEndAllowThreads(__tstate);
22716 if (PyErr_Occurred()) SWIG_fail;
22717 }
22718 resultobj = SWIG_Py_Void();
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22726 PyObject *obj;
22727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22728 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22729 return SWIG_Py_Void();
22730 }
22731
22732 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 return SWIG_Python_InitShadowInstance(args);
22734 }
22735
22736 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22737 PyObject *resultobj = 0;
22738 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22739 wxMouseEvent *result = 0 ;
22740 int val1 ;
22741 int ecode1 = 0 ;
22742 PyObject * obj0 = 0 ;
22743 char * kwnames[] = {
22744 (char *) "mouseType", NULL
22745 };
22746
22747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22748 if (obj0) {
22749 ecode1 = SWIG_AsVal_int(obj0, &val1);
22750 if (!SWIG_IsOK(ecode1)) {
22751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22752 }
22753 arg1 = static_cast< wxEventType >(val1);
22754 }
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22758 wxPyEndAllowThreads(__tstate);
22759 if (PyErr_Occurred()) SWIG_fail;
22760 }
22761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22771 bool result;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 PyObject *swig_obj[1] ;
22775
22776 if (!args) SWIG_fail;
22777 swig_obj[0] = args;
22778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22779 if (!SWIG_IsOK(res1)) {
22780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22781 }
22782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 {
22790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22791 }
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj = 0;
22800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22801 int arg2 = (int) wxMOUSE_BTN_ANY ;
22802 bool result;
22803 void *argp1 = 0 ;
22804 int res1 = 0 ;
22805 int val2 ;
22806 int ecode2 = 0 ;
22807 PyObject * obj0 = 0 ;
22808 PyObject * obj1 = 0 ;
22809 char * kwnames[] = {
22810 (char *) "self",(char *) "but", NULL
22811 };
22812
22813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22815 if (!SWIG_IsOK(res1)) {
22816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22817 }
22818 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22819 if (obj1) {
22820 ecode2 = SWIG_AsVal_int(obj1, &val2);
22821 if (!SWIG_IsOK(ecode2)) {
22822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22823 }
22824 arg2 = static_cast< int >(val2);
22825 }
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj = 0;
22843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22844 int arg2 = (int) wxMOUSE_BTN_ANY ;
22845 bool result;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 int val2 ;
22849 int ecode2 = 0 ;
22850 PyObject * obj0 = 0 ;
22851 PyObject * obj1 = 0 ;
22852 char * kwnames[] = {
22853 (char *) "self",(char *) "but", NULL
22854 };
22855
22856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22858 if (!SWIG_IsOK(res1)) {
22859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22860 }
22861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22862 if (obj1) {
22863 ecode2 = SWIG_AsVal_int(obj1, &val2);
22864 if (!SWIG_IsOK(ecode2)) {
22865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22866 }
22867 arg2 = static_cast< int >(val2);
22868 }
22869 {
22870 PyThreadState* __tstate = wxPyBeginAllowThreads();
22871 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 {
22876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22877 }
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22885 PyObject *resultobj = 0;
22886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22887 int arg2 = (int) wxMOUSE_BTN_ANY ;
22888 bool result;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 int val2 ;
22892 int ecode2 = 0 ;
22893 PyObject * obj0 = 0 ;
22894 PyObject * obj1 = 0 ;
22895 char * kwnames[] = {
22896 (char *) "self",(char *) "but", NULL
22897 };
22898
22899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22901 if (!SWIG_IsOK(res1)) {
22902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22903 }
22904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22905 if (obj1) {
22906 ecode2 = SWIG_AsVal_int(obj1, &val2);
22907 if (!SWIG_IsOK(ecode2)) {
22908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22909 }
22910 arg2 = static_cast< int >(val2);
22911 }
22912 {
22913 PyThreadState* __tstate = wxPyBeginAllowThreads();
22914 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 {
22919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22928 PyObject *resultobj = 0;
22929 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22930 int arg2 ;
22931 bool result;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 int val2 ;
22935 int ecode2 = 0 ;
22936 PyObject * obj0 = 0 ;
22937 PyObject * obj1 = 0 ;
22938 char * kwnames[] = {
22939 (char *) "self",(char *) "button", NULL
22940 };
22941
22942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22944 if (!SWIG_IsOK(res1)) {
22945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22946 }
22947 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22948 ecode2 = SWIG_AsVal_int(obj1, &val2);
22949 if (!SWIG_IsOK(ecode2)) {
22950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22951 }
22952 arg2 = static_cast< int >(val2);
22953 {
22954 PyThreadState* __tstate = wxPyBeginAllowThreads();
22955 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22956 wxPyEndAllowThreads(__tstate);
22957 if (PyErr_Occurred()) SWIG_fail;
22958 }
22959 {
22960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22961 }
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22971 int arg2 ;
22972 bool result;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 int val2 ;
22976 int ecode2 = 0 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char * kwnames[] = {
22980 (char *) "self",(char *) "but", NULL
22981 };
22982
22983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22987 }
22988 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22989 ecode2 = SWIG_AsVal_int(obj1, &val2);
22990 if (!SWIG_IsOK(ecode2)) {
22991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22992 }
22993 arg2 = static_cast< int >(val2);
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22997 wxPyEndAllowThreads(__tstate);
22998 if (PyErr_Occurred()) SWIG_fail;
22999 }
23000 {
23001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23010 PyObject *resultobj = 0;
23011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23012 int result;
23013 void *argp1 = 0 ;
23014 int res1 = 0 ;
23015 PyObject *swig_obj[1] ;
23016
23017 if (!args) SWIG_fail;
23018 swig_obj[0] = args;
23019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23020 if (!SWIG_IsOK(res1)) {
23021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23022 }
23023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23024 {
23025 PyThreadState* __tstate = wxPyBeginAllowThreads();
23026 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 resultobj = SWIG_From_int(static_cast< int >(result));
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23038 PyObject *resultobj = 0;
23039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23040 bool result;
23041 void *argp1 = 0 ;
23042 int res1 = 0 ;
23043 PyObject *swig_obj[1] ;
23044
23045 if (!args) SWIG_fail;
23046 swig_obj[0] = args;
23047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23048 if (!SWIG_IsOK(res1)) {
23049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23050 }
23051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23052 {
23053 PyThreadState* __tstate = wxPyBeginAllowThreads();
23054 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 {
23059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23060 }
23061 return resultobj;
23062 fail:
23063 return NULL;
23064 }
23065
23066
23067 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23068 PyObject *resultobj = 0;
23069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23070 bool result;
23071 void *argp1 = 0 ;
23072 int res1 = 0 ;
23073 PyObject *swig_obj[1] ;
23074
23075 if (!args) SWIG_fail;
23076 swig_obj[0] = args;
23077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23078 if (!SWIG_IsOK(res1)) {
23079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23080 }
23081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23082 {
23083 PyThreadState* __tstate = wxPyBeginAllowThreads();
23084 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 {
23089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23090 }
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 PyObject *resultobj = 0;
23099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23100 bool result;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 PyObject *swig_obj[1] ;
23104
23105 if (!args) SWIG_fail;
23106 swig_obj[0] = args;
23107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23108 if (!SWIG_IsOK(res1)) {
23109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23110 }
23111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23112 {
23113 PyThreadState* __tstate = wxPyBeginAllowThreads();
23114 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 {
23119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23120 }
23121 return resultobj;
23122 fail:
23123 return NULL;
23124 }
23125
23126
23127 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23128 PyObject *resultobj = 0;
23129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23130 bool result;
23131 void *argp1 = 0 ;
23132 int res1 = 0 ;
23133 PyObject *swig_obj[1] ;
23134
23135 if (!args) SWIG_fail;
23136 swig_obj[0] = args;
23137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23138 if (!SWIG_IsOK(res1)) {
23139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23140 }
23141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23145 wxPyEndAllowThreads(__tstate);
23146 if (PyErr_Occurred()) SWIG_fail;
23147 }
23148 {
23149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23150 }
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 PyObject *resultobj = 0;
23159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23160 bool result;
23161 void *argp1 = 0 ;
23162 int res1 = 0 ;
23163 PyObject *swig_obj[1] ;
23164
23165 if (!args) SWIG_fail;
23166 swig_obj[0] = args;
23167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23168 if (!SWIG_IsOK(res1)) {
23169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23170 }
23171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23175 wxPyEndAllowThreads(__tstate);
23176 if (PyErr_Occurred()) SWIG_fail;
23177 }
23178 {
23179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23180 }
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23188 PyObject *resultobj = 0;
23189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23190 bool result;
23191 void *argp1 = 0 ;
23192 int res1 = 0 ;
23193 PyObject *swig_obj[1] ;
23194
23195 if (!args) SWIG_fail;
23196 swig_obj[0] = args;
23197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23198 if (!SWIG_IsOK(res1)) {
23199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23200 }
23201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23205 wxPyEndAllowThreads(__tstate);
23206 if (PyErr_Occurred()) SWIG_fail;
23207 }
23208 {
23209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23210 }
23211 return resultobj;
23212 fail:
23213 return NULL;
23214 }
23215
23216
23217 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23218 PyObject *resultobj = 0;
23219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23220 bool result;
23221 void *argp1 = 0 ;
23222 int res1 = 0 ;
23223 PyObject *swig_obj[1] ;
23224
23225 if (!args) SWIG_fail;
23226 swig_obj[0] = args;
23227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23228 if (!SWIG_IsOK(res1)) {
23229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23230 }
23231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23232 {
23233 PyThreadState* __tstate = wxPyBeginAllowThreads();
23234 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 {
23239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23240 }
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23248 PyObject *resultobj = 0;
23249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23250 bool result;
23251 void *argp1 = 0 ;
23252 int res1 = 0 ;
23253 PyObject *swig_obj[1] ;
23254
23255 if (!args) SWIG_fail;
23256 swig_obj[0] = args;
23257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23260 }
23261 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23262 {
23263 PyThreadState* __tstate = wxPyBeginAllowThreads();
23264 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 {
23269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23270 }
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23278 PyObject *resultobj = 0;
23279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23280 bool result;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 PyObject *swig_obj[1] ;
23284
23285 if (!args) SWIG_fail;
23286 swig_obj[0] = args;
23287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23288 if (!SWIG_IsOK(res1)) {
23289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23290 }
23291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 {
23299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23300 }
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23308 PyObject *resultobj = 0;
23309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23310 bool result;
23311 void *argp1 = 0 ;
23312 int res1 = 0 ;
23313 PyObject *swig_obj[1] ;
23314
23315 if (!args) SWIG_fail;
23316 swig_obj[0] = args;
23317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23318 if (!SWIG_IsOK(res1)) {
23319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23320 }
23321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 {
23329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23330 }
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23338 PyObject *resultobj = 0;
23339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23340 bool result;
23341 void *argp1 = 0 ;
23342 int res1 = 0 ;
23343 PyObject *swig_obj[1] ;
23344
23345 if (!args) SWIG_fail;
23346 swig_obj[0] = args;
23347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23348 if (!SWIG_IsOK(res1)) {
23349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23350 }
23351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 {
23359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23360 }
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23368 PyObject *resultobj = 0;
23369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23370 bool result;
23371 void *argp1 = 0 ;
23372 int res1 = 0 ;
23373 PyObject *swig_obj[1] ;
23374
23375 if (!args) SWIG_fail;
23376 swig_obj[0] = args;
23377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23378 if (!SWIG_IsOK(res1)) {
23379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23380 }
23381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23382 {
23383 PyThreadState* __tstate = wxPyBeginAllowThreads();
23384 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 {
23389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23390 }
23391 return resultobj;
23392 fail:
23393 return NULL;
23394 }
23395
23396
23397 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23398 PyObject *resultobj = 0;
23399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23400 bool result;
23401 void *argp1 = 0 ;
23402 int res1 = 0 ;
23403 PyObject *swig_obj[1] ;
23404
23405 if (!args) SWIG_fail;
23406 swig_obj[0] = args;
23407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23408 if (!SWIG_IsOK(res1)) {
23409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23410 }
23411 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23415 wxPyEndAllowThreads(__tstate);
23416 if (PyErr_Occurred()) SWIG_fail;
23417 }
23418 {
23419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23420 }
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23428 PyObject *resultobj = 0;
23429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23430 bool result;
23431 void *argp1 = 0 ;
23432 int res1 = 0 ;
23433 PyObject *swig_obj[1] ;
23434
23435 if (!args) SWIG_fail;
23436 swig_obj[0] = args;
23437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23440 }
23441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23445 wxPyEndAllowThreads(__tstate);
23446 if (PyErr_Occurred()) SWIG_fail;
23447 }
23448 {
23449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23450 }
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23458 PyObject *resultobj = 0;
23459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23460 bool result;
23461 void *argp1 = 0 ;
23462 int res1 = 0 ;
23463 PyObject *swig_obj[1] ;
23464
23465 if (!args) SWIG_fail;
23466 swig_obj[0] = args;
23467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23468 if (!SWIG_IsOK(res1)) {
23469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23470 }
23471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (bool)(arg1)->LeftIsDown();
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 {
23479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23480 }
23481 return resultobj;
23482 fail:
23483 return NULL;
23484 }
23485
23486
23487 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23488 PyObject *resultobj = 0;
23489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23490 bool result;
23491 void *argp1 = 0 ;
23492 int res1 = 0 ;
23493 PyObject *swig_obj[1] ;
23494
23495 if (!args) SWIG_fail;
23496 swig_obj[0] = args;
23497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23498 if (!SWIG_IsOK(res1)) {
23499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23500 }
23501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 result = (bool)(arg1)->MiddleIsDown();
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 {
23509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23510 }
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23518 PyObject *resultobj = 0;
23519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23520 bool result;
23521 void *argp1 = 0 ;
23522 int res1 = 0 ;
23523 PyObject *swig_obj[1] ;
23524
23525 if (!args) SWIG_fail;
23526 swig_obj[0] = args;
23527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23528 if (!SWIG_IsOK(res1)) {
23529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23530 }
23531 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 result = (bool)(arg1)->RightIsDown();
23535 wxPyEndAllowThreads(__tstate);
23536 if (PyErr_Occurred()) SWIG_fail;
23537 }
23538 {
23539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23540 }
23541 return resultobj;
23542 fail:
23543 return NULL;
23544 }
23545
23546
23547 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23548 PyObject *resultobj = 0;
23549 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23550 bool result;
23551 void *argp1 = 0 ;
23552 int res1 = 0 ;
23553 PyObject *swig_obj[1] ;
23554
23555 if (!args) SWIG_fail;
23556 swig_obj[0] = args;
23557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23558 if (!SWIG_IsOK(res1)) {
23559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23560 }
23561 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 {
23569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23570 }
23571 return resultobj;
23572 fail:
23573 return NULL;
23574 }
23575
23576
23577 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23578 PyObject *resultobj = 0;
23579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23580 bool result;
23581 void *argp1 = 0 ;
23582 int res1 = 0 ;
23583 PyObject *swig_obj[1] ;
23584
23585 if (!args) SWIG_fail;
23586 swig_obj[0] = args;
23587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23590 }
23591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23592 {
23593 PyThreadState* __tstate = wxPyBeginAllowThreads();
23594 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23608 PyObject *resultobj = 0;
23609 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23610 bool result;
23611 void *argp1 = 0 ;
23612 int res1 = 0 ;
23613 PyObject *swig_obj[1] ;
23614
23615 if (!args) SWIG_fail;
23616 swig_obj[0] = args;
23617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23618 if (!SWIG_IsOK(res1)) {
23619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23620 }
23621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23622 {
23623 PyThreadState* __tstate = wxPyBeginAllowThreads();
23624 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 {
23629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23630 }
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23638 PyObject *resultobj = 0;
23639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23640 bool result;
23641 void *argp1 = 0 ;
23642 int res1 = 0 ;
23643 PyObject *swig_obj[1] ;
23644
23645 if (!args) SWIG_fail;
23646 swig_obj[0] = args;
23647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23648 if (!SWIG_IsOK(res1)) {
23649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23650 }
23651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23652 {
23653 PyThreadState* __tstate = wxPyBeginAllowThreads();
23654 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 {
23659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23668 PyObject *resultobj = 0;
23669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23670 wxPoint result;
23671 void *argp1 = 0 ;
23672 int res1 = 0 ;
23673 PyObject *swig_obj[1] ;
23674
23675 if (!args) SWIG_fail;
23676 swig_obj[0] = args;
23677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23678 if (!SWIG_IsOK(res1)) {
23679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23680 }
23681 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23682 {
23683 PyThreadState* __tstate = wxPyBeginAllowThreads();
23684 result = (arg1)->GetPosition();
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23696 PyObject *resultobj = 0;
23697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23698 long *arg2 = (long *) 0 ;
23699 long *arg3 = (long *) 0 ;
23700 void *argp1 = 0 ;
23701 int res1 = 0 ;
23702 long temp2 ;
23703 int res2 = SWIG_TMPOBJ ;
23704 long temp3 ;
23705 int res3 = SWIG_TMPOBJ ;
23706 PyObject *swig_obj[1] ;
23707
23708 arg2 = &temp2;
23709 arg3 = &temp3;
23710 if (!args) SWIG_fail;
23711 swig_obj[0] = args;
23712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23713 if (!SWIG_IsOK(res1)) {
23714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23715 }
23716 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 (arg1)->GetPosition(arg2,arg3);
23720 wxPyEndAllowThreads(__tstate);
23721 if (PyErr_Occurred()) SWIG_fail;
23722 }
23723 resultobj = SWIG_Py_Void();
23724 if (SWIG_IsTmpObj(res2)) {
23725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23726 } else {
23727 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23729 }
23730 if (SWIG_IsTmpObj(res3)) {
23731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23732 } else {
23733 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23735 }
23736 return resultobj;
23737 fail:
23738 return NULL;
23739 }
23740
23741
23742 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj = 0;
23744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23745 wxDC *arg2 = 0 ;
23746 wxPoint result;
23747 void *argp1 = 0 ;
23748 int res1 = 0 ;
23749 void *argp2 = 0 ;
23750 int res2 = 0 ;
23751 PyObject * obj0 = 0 ;
23752 PyObject * obj1 = 0 ;
23753 char * kwnames[] = {
23754 (char *) "self",(char *) "dc", NULL
23755 };
23756
23757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23759 if (!SWIG_IsOK(res1)) {
23760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23761 }
23762 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23764 if (!SWIG_IsOK(res2)) {
23765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23766 }
23767 if (!argp2) {
23768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23769 }
23770 arg2 = reinterpret_cast< wxDC * >(argp2);
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *resultobj = 0;
23786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23787 int result;
23788 void *argp1 = 0 ;
23789 int res1 = 0 ;
23790 PyObject *swig_obj[1] ;
23791
23792 if (!args) SWIG_fail;
23793 swig_obj[0] = args;
23794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23795 if (!SWIG_IsOK(res1)) {
23796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23797 }
23798 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23799 {
23800 PyThreadState* __tstate = wxPyBeginAllowThreads();
23801 result = (int)((wxMouseEvent const *)arg1)->GetX();
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 resultobj = SWIG_From_int(static_cast< int >(result));
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23813 PyObject *resultobj = 0;
23814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23815 int result;
23816 void *argp1 = 0 ;
23817 int res1 = 0 ;
23818 PyObject *swig_obj[1] ;
23819
23820 if (!args) SWIG_fail;
23821 swig_obj[0] = args;
23822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23823 if (!SWIG_IsOK(res1)) {
23824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23825 }
23826 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23827 {
23828 PyThreadState* __tstate = wxPyBeginAllowThreads();
23829 result = (int)((wxMouseEvent const *)arg1)->GetY();
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 resultobj = SWIG_From_int(static_cast< int >(result));
23834 return resultobj;
23835 fail:
23836 return NULL;
23837 }
23838
23839
23840 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841 PyObject *resultobj = 0;
23842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23843 int result;
23844 void *argp1 = 0 ;
23845 int res1 = 0 ;
23846 PyObject *swig_obj[1] ;
23847
23848 if (!args) SWIG_fail;
23849 swig_obj[0] = args;
23850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23851 if (!SWIG_IsOK(res1)) {
23852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23853 }
23854 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_From_int(static_cast< int >(result));
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *resultobj = 0;
23870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23871 int result;
23872 void *argp1 = 0 ;
23873 int res1 = 0 ;
23874 PyObject *swig_obj[1] ;
23875
23876 if (!args) SWIG_fail;
23877 swig_obj[0] = args;
23878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23879 if (!SWIG_IsOK(res1)) {
23880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23881 }
23882 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23886 wxPyEndAllowThreads(__tstate);
23887 if (PyErr_Occurred()) SWIG_fail;
23888 }
23889 resultobj = SWIG_From_int(static_cast< int >(result));
23890 return resultobj;
23891 fail:
23892 return NULL;
23893 }
23894
23895
23896 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23897 PyObject *resultobj = 0;
23898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23899 int result;
23900 void *argp1 = 0 ;
23901 int res1 = 0 ;
23902 PyObject *swig_obj[1] ;
23903
23904 if (!args) SWIG_fail;
23905 swig_obj[0] = args;
23906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23907 if (!SWIG_IsOK(res1)) {
23908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23909 }
23910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23914 wxPyEndAllowThreads(__tstate);
23915 if (PyErr_Occurred()) SWIG_fail;
23916 }
23917 resultobj = SWIG_From_int(static_cast< int >(result));
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23925 PyObject *resultobj = 0;
23926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23927 bool result;
23928 void *argp1 = 0 ;
23929 int res1 = 0 ;
23930 PyObject *swig_obj[1] ;
23931
23932 if (!args) SWIG_fail;
23933 swig_obj[0] = args;
23934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23935 if (!SWIG_IsOK(res1)) {
23936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23937 }
23938 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23942 wxPyEndAllowThreads(__tstate);
23943 if (PyErr_Occurred()) SWIG_fail;
23944 }
23945 {
23946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23947 }
23948 return resultobj;
23949 fail:
23950 return NULL;
23951 }
23952
23953
23954 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23955 PyObject *resultobj = 0;
23956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23957 int arg2 ;
23958 void *argp1 = 0 ;
23959 int res1 = 0 ;
23960 int val2 ;
23961 int ecode2 = 0 ;
23962 PyObject *swig_obj[2] ;
23963
23964 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23966 if (!SWIG_IsOK(res1)) {
23967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23968 }
23969 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23970 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23971 if (!SWIG_IsOK(ecode2)) {
23972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23973 }
23974 arg2 = static_cast< int >(val2);
23975 if (arg1) (arg1)->m_x = arg2;
23976
23977 resultobj = SWIG_Py_Void();
23978 return resultobj;
23979 fail:
23980 return NULL;
23981 }
23982
23983
23984 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23985 PyObject *resultobj = 0;
23986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23987 int result;
23988 void *argp1 = 0 ;
23989 int res1 = 0 ;
23990 PyObject *swig_obj[1] ;
23991
23992 if (!args) SWIG_fail;
23993 swig_obj[0] = args;
23994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23995 if (!SWIG_IsOK(res1)) {
23996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23997 }
23998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23999 result = (int) ((arg1)->m_x);
24000 resultobj = SWIG_From_int(static_cast< int >(result));
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008 PyObject *resultobj = 0;
24009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24010 int arg2 ;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 int val2 ;
24014 int ecode2 = 0 ;
24015 PyObject *swig_obj[2] ;
24016
24017 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24019 if (!SWIG_IsOK(res1)) {
24020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24021 }
24022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24023 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24024 if (!SWIG_IsOK(ecode2)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24026 }
24027 arg2 = static_cast< int >(val2);
24028 if (arg1) (arg1)->m_y = arg2;
24029
24030 resultobj = SWIG_Py_Void();
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24038 PyObject *resultobj = 0;
24039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24040 int result;
24041 void *argp1 = 0 ;
24042 int res1 = 0 ;
24043 PyObject *swig_obj[1] ;
24044
24045 if (!args) SWIG_fail;
24046 swig_obj[0] = args;
24047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24048 if (!SWIG_IsOK(res1)) {
24049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24050 }
24051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24052 result = (int) ((arg1)->m_y);
24053 resultobj = SWIG_From_int(static_cast< int >(result));
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24061 PyObject *resultobj = 0;
24062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24063 bool arg2 ;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 bool val2 ;
24067 int ecode2 = 0 ;
24068 PyObject *swig_obj[2] ;
24069
24070 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24072 if (!SWIG_IsOK(res1)) {
24073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24074 }
24075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24076 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24077 if (!SWIG_IsOK(ecode2)) {
24078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24079 }
24080 arg2 = static_cast< bool >(val2);
24081 if (arg1) (arg1)->m_leftDown = arg2;
24082
24083 resultobj = SWIG_Py_Void();
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24091 PyObject *resultobj = 0;
24092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24093 bool result;
24094 void *argp1 = 0 ;
24095 int res1 = 0 ;
24096 PyObject *swig_obj[1] ;
24097
24098 if (!args) SWIG_fail;
24099 swig_obj[0] = args;
24100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24101 if (!SWIG_IsOK(res1)) {
24102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24103 }
24104 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24105 result = (bool) ((arg1)->m_leftDown);
24106 {
24107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24108 }
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *resultobj = 0;
24117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24118 bool arg2 ;
24119 void *argp1 = 0 ;
24120 int res1 = 0 ;
24121 bool val2 ;
24122 int ecode2 = 0 ;
24123 PyObject *swig_obj[2] ;
24124
24125 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24127 if (!SWIG_IsOK(res1)) {
24128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24129 }
24130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24131 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24132 if (!SWIG_IsOK(ecode2)) {
24133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24134 }
24135 arg2 = static_cast< bool >(val2);
24136 if (arg1) (arg1)->m_middleDown = arg2;
24137
24138 resultobj = SWIG_Py_Void();
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24146 PyObject *resultobj = 0;
24147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24148 bool result;
24149 void *argp1 = 0 ;
24150 int res1 = 0 ;
24151 PyObject *swig_obj[1] ;
24152
24153 if (!args) SWIG_fail;
24154 swig_obj[0] = args;
24155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24156 if (!SWIG_IsOK(res1)) {
24157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24158 }
24159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24160 result = (bool) ((arg1)->m_middleDown);
24161 {
24162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24163 }
24164 return resultobj;
24165 fail:
24166 return NULL;
24167 }
24168
24169
24170 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24171 PyObject *resultobj = 0;
24172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24173 bool arg2 ;
24174 void *argp1 = 0 ;
24175 int res1 = 0 ;
24176 bool val2 ;
24177 int ecode2 = 0 ;
24178 PyObject *swig_obj[2] ;
24179
24180 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24182 if (!SWIG_IsOK(res1)) {
24183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24184 }
24185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24186 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24187 if (!SWIG_IsOK(ecode2)) {
24188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24189 }
24190 arg2 = static_cast< bool >(val2);
24191 if (arg1) (arg1)->m_rightDown = arg2;
24192
24193 resultobj = SWIG_Py_Void();
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24201 PyObject *resultobj = 0;
24202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24203 bool result;
24204 void *argp1 = 0 ;
24205 int res1 = 0 ;
24206 PyObject *swig_obj[1] ;
24207
24208 if (!args) SWIG_fail;
24209 swig_obj[0] = args;
24210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24213 }
24214 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24215 result = (bool) ((arg1)->m_rightDown);
24216 {
24217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24218 }
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24226 PyObject *resultobj = 0;
24227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24228 bool arg2 ;
24229 void *argp1 = 0 ;
24230 int res1 = 0 ;
24231 bool val2 ;
24232 int ecode2 = 0 ;
24233 PyObject *swig_obj[2] ;
24234
24235 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24237 if (!SWIG_IsOK(res1)) {
24238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24239 }
24240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24241 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24242 if (!SWIG_IsOK(ecode2)) {
24243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24244 }
24245 arg2 = static_cast< bool >(val2);
24246 if (arg1) (arg1)->m_controlDown = arg2;
24247
24248 resultobj = SWIG_Py_Void();
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24256 PyObject *resultobj = 0;
24257 wxMouseEvent *arg1 = (wxMouseEvent *) 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_wxMouseEvent, 0 | 0 );
24266 if (!SWIG_IsOK(res1)) {
24267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24268 }
24269 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24270 result = (bool) ((arg1)->m_controlDown);
24271 {
24272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281 PyObject *resultobj = 0;
24282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24283 bool arg2 ;
24284 void *argp1 = 0 ;
24285 int res1 = 0 ;
24286 bool val2 ;
24287 int ecode2 = 0 ;
24288 PyObject *swig_obj[2] ;
24289
24290 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24296 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24297 if (!SWIG_IsOK(ecode2)) {
24298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24299 }
24300 arg2 = static_cast< bool >(val2);
24301 if (arg1) (arg1)->m_shiftDown = arg2;
24302
24303 resultobj = SWIG_Py_Void();
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 PyObject *resultobj = 0;
24312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24313 bool result;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 PyObject *swig_obj[1] ;
24317
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24323 }
24324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24325 result = (bool) ((arg1)->m_shiftDown);
24326 {
24327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24328 }
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *resultobj = 0;
24337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24338 bool arg2 ;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 bool val2 ;
24342 int ecode2 = 0 ;
24343 PyObject *swig_obj[2] ;
24344
24345 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24347 if (!SWIG_IsOK(res1)) {
24348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24349 }
24350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24351 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24352 if (!SWIG_IsOK(ecode2)) {
24353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24354 }
24355 arg2 = static_cast< bool >(val2);
24356 if (arg1) (arg1)->m_altDown = arg2;
24357
24358 resultobj = SWIG_Py_Void();
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24366 PyObject *resultobj = 0;
24367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24368 bool result;
24369 void *argp1 = 0 ;
24370 int res1 = 0 ;
24371 PyObject *swig_obj[1] ;
24372
24373 if (!args) SWIG_fail;
24374 swig_obj[0] = args;
24375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24376 if (!SWIG_IsOK(res1)) {
24377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24378 }
24379 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24380 result = (bool) ((arg1)->m_altDown);
24381 {
24382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24383 }
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24391 PyObject *resultobj = 0;
24392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24393 bool arg2 ;
24394 void *argp1 = 0 ;
24395 int res1 = 0 ;
24396 bool val2 ;
24397 int ecode2 = 0 ;
24398 PyObject *swig_obj[2] ;
24399
24400 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24402 if (!SWIG_IsOK(res1)) {
24403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24404 }
24405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24406 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24407 if (!SWIG_IsOK(ecode2)) {
24408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24409 }
24410 arg2 = static_cast< bool >(val2);
24411 if (arg1) (arg1)->m_metaDown = arg2;
24412
24413 resultobj = SWIG_Py_Void();
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24421 PyObject *resultobj = 0;
24422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24423 bool result;
24424 void *argp1 = 0 ;
24425 int res1 = 0 ;
24426 PyObject *swig_obj[1] ;
24427
24428 if (!args) SWIG_fail;
24429 swig_obj[0] = args;
24430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24433 }
24434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24435 result = (bool) ((arg1)->m_metaDown);
24436 {
24437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24438 }
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 PyObject *resultobj = 0;
24447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24448 int arg2 ;
24449 void *argp1 = 0 ;
24450 int res1 = 0 ;
24451 int val2 ;
24452 int ecode2 = 0 ;
24453 PyObject *swig_obj[2] ;
24454
24455 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24457 if (!SWIG_IsOK(res1)) {
24458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24459 }
24460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24462 if (!SWIG_IsOK(ecode2)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24464 }
24465 arg2 = static_cast< int >(val2);
24466 if (arg1) (arg1)->m_wheelRotation = arg2;
24467
24468 resultobj = SWIG_Py_Void();
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24476 PyObject *resultobj = 0;
24477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24478 int result;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 PyObject *swig_obj[1] ;
24482
24483 if (!args) SWIG_fail;
24484 swig_obj[0] = args;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24490 result = (int) ((arg1)->m_wheelRotation);
24491 resultobj = SWIG_From_int(static_cast< int >(result));
24492 return resultobj;
24493 fail:
24494 return NULL;
24495 }
24496
24497
24498 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24499 PyObject *resultobj = 0;
24500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24501 int arg2 ;
24502 void *argp1 = 0 ;
24503 int res1 = 0 ;
24504 int val2 ;
24505 int ecode2 = 0 ;
24506 PyObject *swig_obj[2] ;
24507
24508 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24510 if (!SWIG_IsOK(res1)) {
24511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24512 }
24513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24514 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24515 if (!SWIG_IsOK(ecode2)) {
24516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24517 }
24518 arg2 = static_cast< int >(val2);
24519 if (arg1) (arg1)->m_wheelDelta = arg2;
24520
24521 resultobj = SWIG_Py_Void();
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *resultobj = 0;
24530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24531 int result;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 PyObject *swig_obj[1] ;
24535
24536 if (!args) SWIG_fail;
24537 swig_obj[0] = args;
24538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24539 if (!SWIG_IsOK(res1)) {
24540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24541 }
24542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24543 result = (int) ((arg1)->m_wheelDelta);
24544 resultobj = SWIG_From_int(static_cast< int >(result));
24545 return resultobj;
24546 fail:
24547 return NULL;
24548 }
24549
24550
24551 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24552 PyObject *resultobj = 0;
24553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24554 int arg2 ;
24555 void *argp1 = 0 ;
24556 int res1 = 0 ;
24557 int val2 ;
24558 int ecode2 = 0 ;
24559 PyObject *swig_obj[2] ;
24560
24561 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24563 if (!SWIG_IsOK(res1)) {
24564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24565 }
24566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24567 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24568 if (!SWIG_IsOK(ecode2)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24570 }
24571 arg2 = static_cast< int >(val2);
24572 if (arg1) (arg1)->m_linesPerAction = arg2;
24573
24574 resultobj = SWIG_Py_Void();
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 PyObject *resultobj = 0;
24583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24584 int result;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 PyObject *swig_obj[1] ;
24588
24589 if (!args) SWIG_fail;
24590 swig_obj[0] = args;
24591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24592 if (!SWIG_IsOK(res1)) {
24593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24594 }
24595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24596 result = (int) ((arg1)->m_linesPerAction);
24597 resultobj = SWIG_From_int(static_cast< int >(result));
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24605 PyObject *obj;
24606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24607 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24608 return SWIG_Py_Void();
24609 }
24610
24611 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 return SWIG_Python_InitShadowInstance(args);
24613 }
24614
24615 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj = 0;
24617 int arg1 = (int) 0 ;
24618 int arg2 = (int) 0 ;
24619 wxSetCursorEvent *result = 0 ;
24620 int val1 ;
24621 int ecode1 = 0 ;
24622 int val2 ;
24623 int ecode2 = 0 ;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char * kwnames[] = {
24627 (char *) "x",(char *) "y", NULL
24628 };
24629
24630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24631 if (obj0) {
24632 ecode1 = SWIG_AsVal_int(obj0, &val1);
24633 if (!SWIG_IsOK(ecode1)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24635 }
24636 arg1 = static_cast< int >(val1);
24637 }
24638 if (obj1) {
24639 ecode2 = SWIG_AsVal_int(obj1, &val2);
24640 if (!SWIG_IsOK(ecode2)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24642 }
24643 arg2 = static_cast< int >(val2);
24644 }
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24652 return resultobj;
24653 fail:
24654 return NULL;
24655 }
24656
24657
24658 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24659 PyObject *resultobj = 0;
24660 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24661 int result;
24662 void *argp1 = 0 ;
24663 int res1 = 0 ;
24664 PyObject *swig_obj[1] ;
24665
24666 if (!args) SWIG_fail;
24667 swig_obj[0] = args;
24668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24671 }
24672 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 resultobj = SWIG_From_int(static_cast< int >(result));
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24687 PyObject *resultobj = 0;
24688 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24689 int result;
24690 void *argp1 = 0 ;
24691 int res1 = 0 ;
24692 PyObject *swig_obj[1] ;
24693
24694 if (!args) SWIG_fail;
24695 swig_obj[0] = args;
24696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24697 if (!SWIG_IsOK(res1)) {
24698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24699 }
24700 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 resultobj = SWIG_From_int(static_cast< int >(result));
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24717 wxCursor *arg2 = 0 ;
24718 void *argp1 = 0 ;
24719 int res1 = 0 ;
24720 void *argp2 = 0 ;
24721 int res2 = 0 ;
24722 PyObject * obj0 = 0 ;
24723 PyObject * obj1 = 0 ;
24724 char * kwnames[] = {
24725 (char *) "self",(char *) "cursor", NULL
24726 };
24727
24728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24730 if (!SWIG_IsOK(res1)) {
24731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24732 }
24733 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24734 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24735 if (!SWIG_IsOK(res2)) {
24736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24737 }
24738 if (!argp2) {
24739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24740 }
24741 arg2 = reinterpret_cast< wxCursor * >(argp2);
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 (arg1)->SetCursor((wxCursor const &)*arg2);
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 resultobj = SWIG_Py_Void();
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24756 PyObject *resultobj = 0;
24757 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24758 wxCursor *result = 0 ;
24759 void *argp1 = 0 ;
24760 int res1 = 0 ;
24761 PyObject *swig_obj[1] ;
24762
24763 if (!args) SWIG_fail;
24764 swig_obj[0] = args;
24765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24766 if (!SWIG_IsOK(res1)) {
24767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24768 }
24769 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 {
24773 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24774 result = (wxCursor *) &_result_ref;
24775 }
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 wxCursor* resultptr = new wxCursor(*result);
24781 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24782 }
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24790 PyObject *resultobj = 0;
24791 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24792 bool result;
24793 void *argp1 = 0 ;
24794 int res1 = 0 ;
24795 PyObject *swig_obj[1] ;
24796
24797 if (!args) SWIG_fail;
24798 swig_obj[0] = args;
24799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24800 if (!SWIG_IsOK(res1)) {
24801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24802 }
24803 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24812 }
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24820 PyObject *obj;
24821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24822 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24823 return SWIG_Py_Void();
24824 }
24825
24826 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24827 return SWIG_Python_InitShadowInstance(args);
24828 }
24829
24830 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj = 0;
24832 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24833 wxKeyEvent *result = 0 ;
24834 int val1 ;
24835 int ecode1 = 0 ;
24836 PyObject * obj0 = 0 ;
24837 char * kwnames[] = {
24838 (char *) "eventType", NULL
24839 };
24840
24841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24842 if (obj0) {
24843 ecode1 = SWIG_AsVal_int(obj0, &val1);
24844 if (!SWIG_IsOK(ecode1)) {
24845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24846 }
24847 arg1 = static_cast< wxEventType >(val1);
24848 }
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24863 PyObject *resultobj = 0;
24864 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24865 int result;
24866 void *argp1 = 0 ;
24867 int res1 = 0 ;
24868 PyObject *swig_obj[1] ;
24869
24870 if (!args) SWIG_fail;
24871 swig_obj[0] = args;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24875 }
24876 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 resultobj = SWIG_From_int(static_cast< int >(result));
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24893 bool result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 PyObject *swig_obj[1] ;
24897
24898 if (!args) SWIG_fail;
24899 swig_obj[0] = args;
24900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24903 }
24904 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24913 }
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24921 PyObject *resultobj = 0;
24922 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24923 bool result;
24924 void *argp1 = 0 ;
24925 int res1 = 0 ;
24926 PyObject *swig_obj[1] ;
24927
24928 if (!args) SWIG_fail;
24929 swig_obj[0] = args;
24930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24931 if (!SWIG_IsOK(res1)) {
24932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24933 }
24934 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24935 {
24936 PyThreadState* __tstate = wxPyBeginAllowThreads();
24937 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 {
24942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24943 }
24944 return resultobj;
24945 fail:
24946 return NULL;
24947 }
24948
24949
24950 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24951 PyObject *resultobj = 0;
24952 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24953 bool result;
24954 void *argp1 = 0 ;
24955 int res1 = 0 ;
24956 PyObject *swig_obj[1] ;
24957
24958 if (!args) SWIG_fail;
24959 swig_obj[0] = args;
24960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24961 if (!SWIG_IsOK(res1)) {
24962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24963 }
24964 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24968 wxPyEndAllowThreads(__tstate);
24969 if (PyErr_Occurred()) SWIG_fail;
24970 }
24971 {
24972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24973 }
24974 return resultobj;
24975 fail:
24976 return NULL;
24977 }
24978
24979
24980 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24981 PyObject *resultobj = 0;
24982 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24983 bool result;
24984 void *argp1 = 0 ;
24985 int res1 = 0 ;
24986 PyObject *swig_obj[1] ;
24987
24988 if (!args) SWIG_fail;
24989 swig_obj[0] = args;
24990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24991 if (!SWIG_IsOK(res1)) {
24992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24993 }
24994 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 {
25002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25011 PyObject *resultobj = 0;
25012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25013 bool result;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 PyObject *swig_obj[1] ;
25017
25018 if (!args) SWIG_fail;
25019 swig_obj[0] = args;
25020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25021 if (!SWIG_IsOK(res1)) {
25022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25023 }
25024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25025 {
25026 PyThreadState* __tstate = wxPyBeginAllowThreads();
25027 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25028 wxPyEndAllowThreads(__tstate);
25029 if (PyErr_Occurred()) SWIG_fail;
25030 }
25031 {
25032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25033 }
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25041 PyObject *resultobj = 0;
25042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25043 bool result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 PyObject *swig_obj[1] ;
25047
25048 if (!args) SWIG_fail;
25049 swig_obj[0] = args;
25050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25053 }
25054 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25058 wxPyEndAllowThreads(__tstate);
25059 if (PyErr_Occurred()) SWIG_fail;
25060 }
25061 {
25062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25071 PyObject *resultobj = 0;
25072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25073 int result;
25074 void *argp1 = 0 ;
25075 int res1 = 0 ;
25076 PyObject *swig_obj[1] ;
25077
25078 if (!args) SWIG_fail;
25079 swig_obj[0] = args;
25080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25081 if (!SWIG_IsOK(res1)) {
25082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25083 }
25084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_From_int(static_cast< int >(result));
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25099 PyObject *resultobj = 0;
25100 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25101 int result;
25102 void *argp1 = 0 ;
25103 int res1 = 0 ;
25104 PyObject *swig_obj[1] ;
25105
25106 if (!args) SWIG_fail;
25107 swig_obj[0] = args;
25108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25109 if (!SWIG_IsOK(res1)) {
25110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25111 }
25112 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_From_int(static_cast< int >(result));
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj = 0;
25128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25129 int arg2 ;
25130 void *argp1 = 0 ;
25131 int res1 = 0 ;
25132 int val2 ;
25133 int ecode2 = 0 ;
25134 PyObject * obj0 = 0 ;
25135 PyObject * obj1 = 0 ;
25136 char * kwnames[] = {
25137 (char *) "self",(char *) "uniChar", NULL
25138 };
25139
25140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25142 if (!SWIG_IsOK(res1)) {
25143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25144 }
25145 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25146 ecode2 = SWIG_AsVal_int(obj1, &val2);
25147 if (!SWIG_IsOK(ecode2)) {
25148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25149 }
25150 arg2 = static_cast< int >(val2);
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_Py_Void();
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25165 PyObject *resultobj = 0;
25166 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25167 unsigned int result;
25168 void *argp1 = 0 ;
25169 int res1 = 0 ;
25170 PyObject *swig_obj[1] ;
25171
25172 if (!args) SWIG_fail;
25173 swig_obj[0] = args;
25174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25177 }
25178 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25182 wxPyEndAllowThreads(__tstate);
25183 if (PyErr_Occurred()) SWIG_fail;
25184 }
25185 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25186 return resultobj;
25187 fail:
25188 return NULL;
25189 }
25190
25191
25192 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25193 PyObject *resultobj = 0;
25194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25195 unsigned int result;
25196 void *argp1 = 0 ;
25197 int res1 = 0 ;
25198 PyObject *swig_obj[1] ;
25199
25200 if (!args) SWIG_fail;
25201 swig_obj[0] = args;
25202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25203 if (!SWIG_IsOK(res1)) {
25204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25205 }
25206 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25210 wxPyEndAllowThreads(__tstate);
25211 if (PyErr_Occurred()) SWIG_fail;
25212 }
25213 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25221 PyObject *resultobj = 0;
25222 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25223 wxPoint result;
25224 void *argp1 = 0 ;
25225 int res1 = 0 ;
25226 PyObject *swig_obj[1] ;
25227
25228 if (!args) SWIG_fail;
25229 swig_obj[0] = args;
25230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25231 if (!SWIG_IsOK(res1)) {
25232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25233 }
25234 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 result = (arg1)->GetPosition();
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 PyObject *resultobj = 0;
25250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25251 long *arg2 = (long *) 0 ;
25252 long *arg3 = (long *) 0 ;
25253 void *argp1 = 0 ;
25254 int res1 = 0 ;
25255 long temp2 ;
25256 int res2 = SWIG_TMPOBJ ;
25257 long temp3 ;
25258 int res3 = SWIG_TMPOBJ ;
25259 PyObject *swig_obj[1] ;
25260
25261 arg2 = &temp2;
25262 arg3 = &temp3;
25263 if (!args) SWIG_fail;
25264 swig_obj[0] = args;
25265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25266 if (!SWIG_IsOK(res1)) {
25267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25268 }
25269 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25270 {
25271 PyThreadState* __tstate = wxPyBeginAllowThreads();
25272 (arg1)->GetPosition(arg2,arg3);
25273 wxPyEndAllowThreads(__tstate);
25274 if (PyErr_Occurred()) SWIG_fail;
25275 }
25276 resultobj = SWIG_Py_Void();
25277 if (SWIG_IsTmpObj(res2)) {
25278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25279 } else {
25280 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25282 }
25283 if (SWIG_IsTmpObj(res3)) {
25284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25285 } else {
25286 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25288 }
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25298 int result;
25299 void *argp1 = 0 ;
25300 int res1 = 0 ;
25301 PyObject *swig_obj[1] ;
25302
25303 if (!args) SWIG_fail;
25304 swig_obj[0] = args;
25305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25308 }
25309 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 result = (int)((wxKeyEvent const *)arg1)->GetX();
25313 wxPyEndAllowThreads(__tstate);
25314 if (PyErr_Occurred()) SWIG_fail;
25315 }
25316 resultobj = SWIG_From_int(static_cast< int >(result));
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *resultobj = 0;
25325 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25326 int result;
25327 void *argp1 = 0 ;
25328 int res1 = 0 ;
25329 PyObject *swig_obj[1] ;
25330
25331 if (!args) SWIG_fail;
25332 swig_obj[0] = args;
25333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25334 if (!SWIG_IsOK(res1)) {
25335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25336 }
25337 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25338 {
25339 PyThreadState* __tstate = wxPyBeginAllowThreads();
25340 result = (int)((wxKeyEvent const *)arg1)->GetY();
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 resultobj = SWIG_From_int(static_cast< int >(result));
25345 return resultobj;
25346 fail:
25347 return NULL;
25348 }
25349
25350
25351 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25352 PyObject *resultobj = 0;
25353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25354 int arg2 ;
25355 void *argp1 = 0 ;
25356 int res1 = 0 ;
25357 int val2 ;
25358 int ecode2 = 0 ;
25359 PyObject *swig_obj[2] ;
25360
25361 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25363 if (!SWIG_IsOK(res1)) {
25364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25365 }
25366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25367 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25368 if (!SWIG_IsOK(ecode2)) {
25369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25370 }
25371 arg2 = static_cast< int >(val2);
25372 if (arg1) (arg1)->m_x = arg2;
25373
25374 resultobj = SWIG_Py_Void();
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382 PyObject *resultobj = 0;
25383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25384 int result;
25385 void *argp1 = 0 ;
25386 int res1 = 0 ;
25387 PyObject *swig_obj[1] ;
25388
25389 if (!args) SWIG_fail;
25390 swig_obj[0] = args;
25391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25392 if (!SWIG_IsOK(res1)) {
25393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25394 }
25395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25396 result = (int) ((arg1)->m_x);
25397 resultobj = SWIG_From_int(static_cast< int >(result));
25398 return resultobj;
25399 fail:
25400 return NULL;
25401 }
25402
25403
25404 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25405 PyObject *resultobj = 0;
25406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25407 int arg2 ;
25408 void *argp1 = 0 ;
25409 int res1 = 0 ;
25410 int val2 ;
25411 int ecode2 = 0 ;
25412 PyObject *swig_obj[2] ;
25413
25414 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25416 if (!SWIG_IsOK(res1)) {
25417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25418 }
25419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25420 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25421 if (!SWIG_IsOK(ecode2)) {
25422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25423 }
25424 arg2 = static_cast< int >(val2);
25425 if (arg1) (arg1)->m_y = arg2;
25426
25427 resultobj = SWIG_Py_Void();
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25437 int result;
25438 void *argp1 = 0 ;
25439 int res1 = 0 ;
25440 PyObject *swig_obj[1] ;
25441
25442 if (!args) SWIG_fail;
25443 swig_obj[0] = args;
25444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25445 if (!SWIG_IsOK(res1)) {
25446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25447 }
25448 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25449 result = (int) ((arg1)->m_y);
25450 resultobj = SWIG_From_int(static_cast< int >(result));
25451 return resultobj;
25452 fail:
25453 return NULL;
25454 }
25455
25456
25457 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25458 PyObject *resultobj = 0;
25459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25460 long arg2 ;
25461 void *argp1 = 0 ;
25462 int res1 = 0 ;
25463 long val2 ;
25464 int ecode2 = 0 ;
25465 PyObject *swig_obj[2] ;
25466
25467 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25469 if (!SWIG_IsOK(res1)) {
25470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25471 }
25472 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25473 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25474 if (!SWIG_IsOK(ecode2)) {
25475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25476 }
25477 arg2 = static_cast< long >(val2);
25478 if (arg1) (arg1)->m_keyCode = arg2;
25479
25480 resultobj = SWIG_Py_Void();
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 PyObject *resultobj = 0;
25489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25490 long result;
25491 void *argp1 = 0 ;
25492 int res1 = 0 ;
25493 PyObject *swig_obj[1] ;
25494
25495 if (!args) SWIG_fail;
25496 swig_obj[0] = args;
25497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25498 if (!SWIG_IsOK(res1)) {
25499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25500 }
25501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25502 result = (long) ((arg1)->m_keyCode);
25503 resultobj = SWIG_From_long(static_cast< long >(result));
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25511 PyObject *resultobj = 0;
25512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25513 bool arg2 ;
25514 void *argp1 = 0 ;
25515 int res1 = 0 ;
25516 bool val2 ;
25517 int ecode2 = 0 ;
25518 PyObject *swig_obj[2] ;
25519
25520 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25522 if (!SWIG_IsOK(res1)) {
25523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25524 }
25525 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25526 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25527 if (!SWIG_IsOK(ecode2)) {
25528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25529 }
25530 arg2 = static_cast< bool >(val2);
25531 if (arg1) (arg1)->m_controlDown = arg2;
25532
25533 resultobj = SWIG_Py_Void();
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25543 bool result;
25544 void *argp1 = 0 ;
25545 int res1 = 0 ;
25546 PyObject *swig_obj[1] ;
25547
25548 if (!args) SWIG_fail;
25549 swig_obj[0] = args;
25550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25551 if (!SWIG_IsOK(res1)) {
25552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25553 }
25554 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25555 result = (bool) ((arg1)->m_controlDown);
25556 {
25557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25558 }
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 PyObject *resultobj = 0;
25567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25568 bool arg2 ;
25569 void *argp1 = 0 ;
25570 int res1 = 0 ;
25571 bool val2 ;
25572 int ecode2 = 0 ;
25573 PyObject *swig_obj[2] ;
25574
25575 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25577 if (!SWIG_IsOK(res1)) {
25578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25579 }
25580 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25581 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25582 if (!SWIG_IsOK(ecode2)) {
25583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25584 }
25585 arg2 = static_cast< bool >(val2);
25586 if (arg1) (arg1)->m_shiftDown = arg2;
25587
25588 resultobj = SWIG_Py_Void();
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25596 PyObject *resultobj = 0;
25597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25598 bool result;
25599 void *argp1 = 0 ;
25600 int res1 = 0 ;
25601 PyObject *swig_obj[1] ;
25602
25603 if (!args) SWIG_fail;
25604 swig_obj[0] = args;
25605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25608 }
25609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25610 result = (bool) ((arg1)->m_shiftDown);
25611 {
25612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25613 }
25614 return resultobj;
25615 fail:
25616 return NULL;
25617 }
25618
25619
25620 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25621 PyObject *resultobj = 0;
25622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25623 bool arg2 ;
25624 void *argp1 = 0 ;
25625 int res1 = 0 ;
25626 bool val2 ;
25627 int ecode2 = 0 ;
25628 PyObject *swig_obj[2] ;
25629
25630 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25632 if (!SWIG_IsOK(res1)) {
25633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25634 }
25635 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25636 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25637 if (!SWIG_IsOK(ecode2)) {
25638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25639 }
25640 arg2 = static_cast< bool >(val2);
25641 if (arg1) (arg1)->m_altDown = arg2;
25642
25643 resultobj = SWIG_Py_Void();
25644 return resultobj;
25645 fail:
25646 return NULL;
25647 }
25648
25649
25650 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25651 PyObject *resultobj = 0;
25652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25653 bool result;
25654 void *argp1 = 0 ;
25655 int res1 = 0 ;
25656 PyObject *swig_obj[1] ;
25657
25658 if (!args) SWIG_fail;
25659 swig_obj[0] = args;
25660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25661 if (!SWIG_IsOK(res1)) {
25662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25663 }
25664 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25665 result = (bool) ((arg1)->m_altDown);
25666 {
25667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25668 }
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25676 PyObject *resultobj = 0;
25677 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25678 bool arg2 ;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 bool val2 ;
25682 int ecode2 = 0 ;
25683 PyObject *swig_obj[2] ;
25684
25685 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25687 if (!SWIG_IsOK(res1)) {
25688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25689 }
25690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25691 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25692 if (!SWIG_IsOK(ecode2)) {
25693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25694 }
25695 arg2 = static_cast< bool >(val2);
25696 if (arg1) (arg1)->m_metaDown = arg2;
25697
25698 resultobj = SWIG_Py_Void();
25699 return resultobj;
25700 fail:
25701 return NULL;
25702 }
25703
25704
25705 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25706 PyObject *resultobj = 0;
25707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25708 bool result;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 PyObject *swig_obj[1] ;
25712
25713 if (!args) SWIG_fail;
25714 swig_obj[0] = args;
25715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25718 }
25719 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25720 result = (bool) ((arg1)->m_metaDown);
25721 {
25722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25723 }
25724 return resultobj;
25725 fail:
25726 return NULL;
25727 }
25728
25729
25730 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25731 PyObject *resultobj = 0;
25732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25733 bool arg2 ;
25734 void *argp1 = 0 ;
25735 int res1 = 0 ;
25736 bool val2 ;
25737 int ecode2 = 0 ;
25738 PyObject *swig_obj[2] ;
25739
25740 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25742 if (!SWIG_IsOK(res1)) {
25743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25744 }
25745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25746 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25747 if (!SWIG_IsOK(ecode2)) {
25748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25749 }
25750 arg2 = static_cast< bool >(val2);
25751 if (arg1) (arg1)->m_scanCode = arg2;
25752
25753 resultobj = SWIG_Py_Void();
25754 return resultobj;
25755 fail:
25756 return NULL;
25757 }
25758
25759
25760 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25761 PyObject *resultobj = 0;
25762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25763 bool result;
25764 void *argp1 = 0 ;
25765 int res1 = 0 ;
25766 PyObject *swig_obj[1] ;
25767
25768 if (!args) SWIG_fail;
25769 swig_obj[0] = args;
25770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25771 if (!SWIG_IsOK(res1)) {
25772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25773 }
25774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25775 result = (bool) ((arg1)->m_scanCode);
25776 {
25777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25778 }
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25786 PyObject *resultobj = 0;
25787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25788 unsigned int arg2 ;
25789 void *argp1 = 0 ;
25790 int res1 = 0 ;
25791 unsigned int val2 ;
25792 int ecode2 = 0 ;
25793 PyObject *swig_obj[2] ;
25794
25795 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25799 }
25800 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25801 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25802 if (!SWIG_IsOK(ecode2)) {
25803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25804 }
25805 arg2 = static_cast< unsigned int >(val2);
25806 if (arg1) (arg1)->m_rawCode = arg2;
25807
25808 resultobj = SWIG_Py_Void();
25809 return resultobj;
25810 fail:
25811 return NULL;
25812 }
25813
25814
25815 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25816 PyObject *resultobj = 0;
25817 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25818 unsigned int result;
25819 void *argp1 = 0 ;
25820 int res1 = 0 ;
25821 PyObject *swig_obj[1] ;
25822
25823 if (!args) SWIG_fail;
25824 swig_obj[0] = args;
25825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25826 if (!SWIG_IsOK(res1)) {
25827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25828 }
25829 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25830 result = (unsigned int) ((arg1)->m_rawCode);
25831 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25839 PyObject *resultobj = 0;
25840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25841 unsigned int arg2 ;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 unsigned int val2 ;
25845 int ecode2 = 0 ;
25846 PyObject *swig_obj[2] ;
25847
25848 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25850 if (!SWIG_IsOK(res1)) {
25851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25852 }
25853 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25854 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25855 if (!SWIG_IsOK(ecode2)) {
25856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25857 }
25858 arg2 = static_cast< unsigned int >(val2);
25859 if (arg1) (arg1)->m_rawFlags = arg2;
25860
25861 resultobj = SWIG_Py_Void();
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869 PyObject *resultobj = 0;
25870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25871 unsigned int result;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 PyObject *swig_obj[1] ;
25875
25876 if (!args) SWIG_fail;
25877 swig_obj[0] = args;
25878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25879 if (!SWIG_IsOK(res1)) {
25880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25881 }
25882 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25883 result = (unsigned int) ((arg1)->m_rawFlags);
25884 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25892 PyObject *obj;
25893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25894 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25895 return SWIG_Py_Void();
25896 }
25897
25898 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25899 return SWIG_Python_InitShadowInstance(args);
25900 }
25901
25902 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25903 PyObject *resultobj = 0;
25904 wxSize const &arg1_defvalue = wxDefaultSize ;
25905 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25906 int arg2 = (int) 0 ;
25907 wxSizeEvent *result = 0 ;
25908 wxSize temp1 ;
25909 int val2 ;
25910 int ecode2 = 0 ;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 char * kwnames[] = {
25914 (char *) "sz",(char *) "winid", NULL
25915 };
25916
25917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25918 if (obj0) {
25919 {
25920 arg1 = &temp1;
25921 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25922 }
25923 }
25924 if (obj1) {
25925 ecode2 = SWIG_AsVal_int(obj1, &val2);
25926 if (!SWIG_IsOK(ecode2)) {
25927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25928 }
25929 arg2 = static_cast< int >(val2);
25930 }
25931 {
25932 PyThreadState* __tstate = wxPyBeginAllowThreads();
25933 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25938 return resultobj;
25939 fail:
25940 return NULL;
25941 }
25942
25943
25944 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25945 PyObject *resultobj = 0;
25946 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25947 wxSize result;
25948 void *argp1 = 0 ;
25949 int res1 = 0 ;
25950 PyObject *swig_obj[1] ;
25951
25952 if (!args) SWIG_fail;
25953 swig_obj[0] = args;
25954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25955 if (!SWIG_IsOK(res1)) {
25956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25957 }
25958 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 result = ((wxSizeEvent const *)arg1)->GetSize();
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 PyObject *resultobj = 0;
25974 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25975 wxRect result;
25976 void *argp1 = 0 ;
25977 int res1 = 0 ;
25978 PyObject *swig_obj[1] ;
25979
25980 if (!args) SWIG_fail;
25981 swig_obj[0] = args;
25982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25983 if (!SWIG_IsOK(res1)) {
25984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25985 }
25986 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25987 {
25988 PyThreadState* __tstate = wxPyBeginAllowThreads();
25989 result = ((wxSizeEvent const *)arg1)->GetRect();
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25994 return resultobj;
25995 fail:
25996 return NULL;
25997 }
25998
25999
26000 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj = 0;
26002 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26003 wxRect arg2 ;
26004 void *argp1 = 0 ;
26005 int res1 = 0 ;
26006 void *argp2 ;
26007 int res2 = 0 ;
26008 PyObject * obj0 = 0 ;
26009 PyObject * obj1 = 0 ;
26010 char * kwnames[] = {
26011 (char *) "self",(char *) "rect", NULL
26012 };
26013
26014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26016 if (!SWIG_IsOK(res1)) {
26017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26018 }
26019 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26020 {
26021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26022 if (!SWIG_IsOK(res2)) {
26023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26024 }
26025 if (!argp2) {
26026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26027 } else {
26028 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26029 arg2 = *temp;
26030 if (SWIG_IsNewObj(res2)) delete temp;
26031 }
26032 }
26033 {
26034 PyThreadState* __tstate = wxPyBeginAllowThreads();
26035 (arg1)->SetRect(arg2);
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 resultobj = SWIG_Py_Void();
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj = 0;
26048 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26049 wxSize arg2 ;
26050 void *argp1 = 0 ;
26051 int res1 = 0 ;
26052 void *argp2 ;
26053 int res2 = 0 ;
26054 PyObject * obj0 = 0 ;
26055 PyObject * obj1 = 0 ;
26056 char * kwnames[] = {
26057 (char *) "self",(char *) "size", NULL
26058 };
26059
26060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26062 if (!SWIG_IsOK(res1)) {
26063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26064 }
26065 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26066 {
26067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26068 if (!SWIG_IsOK(res2)) {
26069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26070 }
26071 if (!argp2) {
26072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26073 } else {
26074 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26075 arg2 = *temp;
26076 if (SWIG_IsNewObj(res2)) delete temp;
26077 }
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 wxSizeEvent_SetSize(arg1,arg2);
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_Py_Void();
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *resultobj = 0;
26094 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26095 wxSize *arg2 = (wxSize *) 0 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 void *argp2 = 0 ;
26099 int res2 = 0 ;
26100 PyObject *swig_obj[2] ;
26101
26102 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26104 if (!SWIG_IsOK(res1)) {
26105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26106 }
26107 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26108 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26109 if (!SWIG_IsOK(res2)) {
26110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26111 }
26112 arg2 = reinterpret_cast< wxSize * >(argp2);
26113 if (arg1) (arg1)->m_size = *arg2;
26114
26115 resultobj = SWIG_Py_Void();
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26123 PyObject *resultobj = 0;
26124 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26125 wxSize *result = 0 ;
26126 void *argp1 = 0 ;
26127 int res1 = 0 ;
26128 PyObject *swig_obj[1] ;
26129
26130 if (!args) SWIG_fail;
26131 swig_obj[0] = args;
26132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26135 }
26136 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26137 result = (wxSize *)& ((arg1)->m_size);
26138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *resultobj = 0;
26147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26148 wxRect *arg2 = (wxRect *) 0 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 void *argp2 = 0 ;
26152 int res2 = 0 ;
26153 PyObject *swig_obj[2] ;
26154
26155 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26157 if (!SWIG_IsOK(res1)) {
26158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26159 }
26160 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26161 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26162 if (!SWIG_IsOK(res2)) {
26163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26164 }
26165 arg2 = reinterpret_cast< wxRect * >(argp2);
26166 if (arg1) (arg1)->m_rect = *arg2;
26167
26168 resultobj = SWIG_Py_Void();
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26176 PyObject *resultobj = 0;
26177 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26178 wxRect *result = 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 PyObject *swig_obj[1] ;
26182
26183 if (!args) SWIG_fail;
26184 swig_obj[0] = args;
26185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26186 if (!SWIG_IsOK(res1)) {
26187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26188 }
26189 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26190 result = (wxRect *)& ((arg1)->m_rect);
26191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26199 PyObject *obj;
26200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26201 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26202 return SWIG_Py_Void();
26203 }
26204
26205 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26206 return SWIG_Python_InitShadowInstance(args);
26207 }
26208
26209 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26210 PyObject *resultobj = 0;
26211 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26212 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26213 int arg2 = (int) 0 ;
26214 wxMoveEvent *result = 0 ;
26215 wxPoint temp1 ;
26216 int val2 ;
26217 int ecode2 = 0 ;
26218 PyObject * obj0 = 0 ;
26219 PyObject * obj1 = 0 ;
26220 char * kwnames[] = {
26221 (char *) "pos",(char *) "winid", NULL
26222 };
26223
26224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26225 if (obj0) {
26226 {
26227 arg1 = &temp1;
26228 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26229 }
26230 }
26231 if (obj1) {
26232 ecode2 = SWIG_AsVal_int(obj1, &val2);
26233 if (!SWIG_IsOK(ecode2)) {
26234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26235 }
26236 arg2 = static_cast< int >(val2);
26237 }
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26252 PyObject *resultobj = 0;
26253 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26254 wxPoint result;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 PyObject *swig_obj[1] ;
26258
26259 if (!args) SWIG_fail;
26260 swig_obj[0] = args;
26261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26262 if (!SWIG_IsOK(res1)) {
26263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26264 }
26265 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = ((wxMoveEvent const *)arg1)->GetPosition();
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26280 PyObject *resultobj = 0;
26281 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26282 wxRect result;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 PyObject *swig_obj[1] ;
26286
26287 if (!args) SWIG_fail;
26288 swig_obj[0] = args;
26289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26290 if (!SWIG_IsOK(res1)) {
26291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26292 }
26293 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = ((wxMoveEvent const *)arg1)->GetRect();
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26310 wxRect *arg2 = 0 ;
26311 void *argp1 = 0 ;
26312 int res1 = 0 ;
26313 wxRect temp2 ;
26314 PyObject * obj0 = 0 ;
26315 PyObject * obj1 = 0 ;
26316 char * kwnames[] = {
26317 (char *) "self",(char *) "rect", NULL
26318 };
26319
26320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26322 if (!SWIG_IsOK(res1)) {
26323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26324 }
26325 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26326 {
26327 arg2 = &temp2;
26328 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26329 }
26330 {
26331 PyThreadState* __tstate = wxPyBeginAllowThreads();
26332 (arg1)->SetRect((wxRect const &)*arg2);
26333 wxPyEndAllowThreads(__tstate);
26334 if (PyErr_Occurred()) SWIG_fail;
26335 }
26336 resultobj = SWIG_Py_Void();
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj = 0;
26345 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26346 wxPoint *arg2 = 0 ;
26347 void *argp1 = 0 ;
26348 int res1 = 0 ;
26349 wxPoint temp2 ;
26350 PyObject * obj0 = 0 ;
26351 PyObject * obj1 = 0 ;
26352 char * kwnames[] = {
26353 (char *) "self",(char *) "pos", NULL
26354 };
26355
26356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26358 if (!SWIG_IsOK(res1)) {
26359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26360 }
26361 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26362 {
26363 arg2 = &temp2;
26364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26365 }
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 (arg1)->SetPosition((wxPoint const &)*arg2);
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 resultobj = SWIG_Py_Void();
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26380 PyObject *obj;
26381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26382 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26383 return SWIG_Py_Void();
26384 }
26385
26386 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26387 return SWIG_Python_InitShadowInstance(args);
26388 }
26389
26390 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj = 0;
26392 int arg1 = (int) 0 ;
26393 wxPaintEvent *result = 0 ;
26394 int val1 ;
26395 int ecode1 = 0 ;
26396 PyObject * obj0 = 0 ;
26397 char * kwnames[] = {
26398 (char *) "Id", NULL
26399 };
26400
26401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26402 if (obj0) {
26403 ecode1 = SWIG_AsVal_int(obj0, &val1);
26404 if (!SWIG_IsOK(ecode1)) {
26405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26406 }
26407 arg1 = static_cast< int >(val1);
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *obj;
26424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26426 return SWIG_Py_Void();
26427 }
26428
26429 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26430 return SWIG_Python_InitShadowInstance(args);
26431 }
26432
26433 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = 0;
26435 int arg1 = (int) 0 ;
26436 wxNcPaintEvent *result = 0 ;
26437 int val1 ;
26438 int ecode1 = 0 ;
26439 PyObject * obj0 = 0 ;
26440 char * kwnames[] = {
26441 (char *) "winid", NULL
26442 };
26443
26444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26445 if (obj0) {
26446 ecode1 = SWIG_AsVal_int(obj0, &val1);
26447 if (!SWIG_IsOK(ecode1)) {
26448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26449 }
26450 arg1 = static_cast< int >(val1);
26451 }
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26466 PyObject *obj;
26467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26468 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26469 return SWIG_Py_Void();
26470 }
26471
26472 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 return SWIG_Python_InitShadowInstance(args);
26474 }
26475
26476 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26477 PyObject *resultobj = 0;
26478 int arg1 = (int) 0 ;
26479 wxDC *arg2 = (wxDC *) NULL ;
26480 wxEraseEvent *result = 0 ;
26481 int val1 ;
26482 int ecode1 = 0 ;
26483 void *argp2 = 0 ;
26484 int res2 = 0 ;
26485 PyObject * obj0 = 0 ;
26486 PyObject * obj1 = 0 ;
26487 char * kwnames[] = {
26488 (char *) "Id",(char *) "dc", NULL
26489 };
26490
26491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26492 if (obj0) {
26493 ecode1 = SWIG_AsVal_int(obj0, &val1);
26494 if (!SWIG_IsOK(ecode1)) {
26495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26496 }
26497 arg1 = static_cast< int >(val1);
26498 }
26499 if (obj1) {
26500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26501 if (!SWIG_IsOK(res2)) {
26502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26503 }
26504 arg2 = reinterpret_cast< wxDC * >(argp2);
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26520 PyObject *resultobj = 0;
26521 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26522 wxDC *result = 0 ;
26523 void *argp1 = 0 ;
26524 int res1 = 0 ;
26525 PyObject *swig_obj[1] ;
26526
26527 if (!args) SWIG_fail;
26528 swig_obj[0] = args;
26529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26530 if (!SWIG_IsOK(res1)) {
26531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26532 }
26533 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 {
26541 resultobj = wxPyMake_wxObject(result, (bool)0);
26542 }
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26550 PyObject *obj;
26551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26552 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26553 return SWIG_Py_Void();
26554 }
26555
26556 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 return SWIG_Python_InitShadowInstance(args);
26558 }
26559
26560 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj = 0;
26562 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26563 int arg2 = (int) 0 ;
26564 wxFocusEvent *result = 0 ;
26565 int val1 ;
26566 int ecode1 = 0 ;
26567 int val2 ;
26568 int ecode2 = 0 ;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 char * kwnames[] = {
26572 (char *) "type",(char *) "winid", NULL
26573 };
26574
26575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26576 if (obj0) {
26577 ecode1 = SWIG_AsVal_int(obj0, &val1);
26578 if (!SWIG_IsOK(ecode1)) {
26579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26580 }
26581 arg1 = static_cast< wxEventType >(val1);
26582 }
26583 if (obj1) {
26584 ecode2 = SWIG_AsVal_int(obj1, &val2);
26585 if (!SWIG_IsOK(ecode2)) {
26586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26587 }
26588 arg2 = static_cast< int >(val2);
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26604 PyObject *resultobj = 0;
26605 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26606 wxWindow *result = 0 ;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 PyObject *swig_obj[1] ;
26610
26611 if (!args) SWIG_fail;
26612 swig_obj[0] = args;
26613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26614 if (!SWIG_IsOK(res1)) {
26615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26616 }
26617 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 {
26625 resultobj = wxPyMake_wxObject(result, (bool)0);
26626 }
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26634 PyObject *resultobj = 0;
26635 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26636 wxWindow *arg2 = (wxWindow *) 0 ;
26637 void *argp1 = 0 ;
26638 int res1 = 0 ;
26639 void *argp2 = 0 ;
26640 int res2 = 0 ;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char * kwnames[] = {
26644 (char *) "self",(char *) "win", NULL
26645 };
26646
26647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26649 if (!SWIG_IsOK(res1)) {
26650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26651 }
26652 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26654 if (!SWIG_IsOK(res2)) {
26655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26656 }
26657 arg2 = reinterpret_cast< wxWindow * >(argp2);
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 (arg1)->SetWindow(arg2);
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 resultobj = SWIG_Py_Void();
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 PyObject *obj;
26673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26674 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26675 return SWIG_Py_Void();
26676 }
26677
26678 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679 return SWIG_Python_InitShadowInstance(args);
26680 }
26681
26682 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26683 PyObject *resultobj = 0;
26684 wxWindow *arg1 = (wxWindow *) NULL ;
26685 wxChildFocusEvent *result = 0 ;
26686 void *argp1 = 0 ;
26687 int res1 = 0 ;
26688 PyObject * obj0 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "win", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26694 if (obj0) {
26695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26696 if (!SWIG_IsOK(res1)) {
26697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26698 }
26699 arg1 = reinterpret_cast< wxWindow * >(argp1);
26700 }
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 PyObject *resultobj = 0;
26716 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26717 wxWindow *result = 0 ;
26718 void *argp1 = 0 ;
26719 int res1 = 0 ;
26720 PyObject *swig_obj[1] ;
26721
26722 if (!args) SWIG_fail;
26723 swig_obj[0] = args;
26724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26725 if (!SWIG_IsOK(res1)) {
26726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26727 }
26728 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 {
26736 resultobj = wxPyMake_wxObject(result, (bool)0);
26737 }
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26745 PyObject *obj;
26746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26747 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26748 return SWIG_Py_Void();
26749 }
26750
26751 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26752 return SWIG_Python_InitShadowInstance(args);
26753 }
26754
26755 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = 0;
26757 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26758 bool arg2 = (bool) true ;
26759 int arg3 = (int) 0 ;
26760 wxActivateEvent *result = 0 ;
26761 int val1 ;
26762 int ecode1 = 0 ;
26763 bool val2 ;
26764 int ecode2 = 0 ;
26765 int val3 ;
26766 int ecode3 = 0 ;
26767 PyObject * obj0 = 0 ;
26768 PyObject * obj1 = 0 ;
26769 PyObject * obj2 = 0 ;
26770 char * kwnames[] = {
26771 (char *) "type",(char *) "active",(char *) "Id", NULL
26772 };
26773
26774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26775 if (obj0) {
26776 ecode1 = SWIG_AsVal_int(obj0, &val1);
26777 if (!SWIG_IsOK(ecode1)) {
26778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26779 }
26780 arg1 = static_cast< wxEventType >(val1);
26781 }
26782 if (obj1) {
26783 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26784 if (!SWIG_IsOK(ecode2)) {
26785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26786 }
26787 arg2 = static_cast< bool >(val2);
26788 }
26789 if (obj2) {
26790 ecode3 = SWIG_AsVal_int(obj2, &val3);
26791 if (!SWIG_IsOK(ecode3)) {
26792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26793 }
26794 arg3 = static_cast< int >(val3);
26795 }
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26803 return resultobj;
26804 fail:
26805 return NULL;
26806 }
26807
26808
26809 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26810 PyObject *resultobj = 0;
26811 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26812 bool result;
26813 void *argp1 = 0 ;
26814 int res1 = 0 ;
26815 PyObject *swig_obj[1] ;
26816
26817 if (!args) SWIG_fail;
26818 swig_obj[0] = args;
26819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26820 if (!SWIG_IsOK(res1)) {
26821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26822 }
26823 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26824 {
26825 PyThreadState* __tstate = wxPyBeginAllowThreads();
26826 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26827 wxPyEndAllowThreads(__tstate);
26828 if (PyErr_Occurred()) SWIG_fail;
26829 }
26830 {
26831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26832 }
26833 return resultobj;
26834 fail:
26835 return NULL;
26836 }
26837
26838
26839 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26840 PyObject *obj;
26841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26842 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26843 return SWIG_Py_Void();
26844 }
26845
26846 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26847 return SWIG_Python_InitShadowInstance(args);
26848 }
26849
26850 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26851 PyObject *resultobj = 0;
26852 int arg1 = (int) 0 ;
26853 wxInitDialogEvent *result = 0 ;
26854 int val1 ;
26855 int ecode1 = 0 ;
26856 PyObject * obj0 = 0 ;
26857 char * kwnames[] = {
26858 (char *) "Id", NULL
26859 };
26860
26861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26862 if (obj0) {
26863 ecode1 = SWIG_AsVal_int(obj0, &val1);
26864 if (!SWIG_IsOK(ecode1)) {
26865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26866 }
26867 arg1 = static_cast< int >(val1);
26868 }
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26883 PyObject *obj;
26884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26885 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26886 return SWIG_Py_Void();
26887 }
26888
26889 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26890 return SWIG_Python_InitShadowInstance(args);
26891 }
26892
26893 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26894 PyObject *resultobj = 0;
26895 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26896 int arg2 = (int) 0 ;
26897 wxMenu *arg3 = (wxMenu *) NULL ;
26898 wxMenuEvent *result = 0 ;
26899 int val1 ;
26900 int ecode1 = 0 ;
26901 int val2 ;
26902 int ecode2 = 0 ;
26903 void *argp3 = 0 ;
26904 int res3 = 0 ;
26905 PyObject * obj0 = 0 ;
26906 PyObject * obj1 = 0 ;
26907 PyObject * obj2 = 0 ;
26908 char * kwnames[] = {
26909 (char *) "type",(char *) "winid",(char *) "menu", NULL
26910 };
26911
26912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26913 if (obj0) {
26914 ecode1 = SWIG_AsVal_int(obj0, &val1);
26915 if (!SWIG_IsOK(ecode1)) {
26916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26917 }
26918 arg1 = static_cast< wxEventType >(val1);
26919 }
26920 if (obj1) {
26921 ecode2 = SWIG_AsVal_int(obj1, &val2);
26922 if (!SWIG_IsOK(ecode2)) {
26923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26924 }
26925 arg2 = static_cast< int >(val2);
26926 }
26927 if (obj2) {
26928 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26929 if (!SWIG_IsOK(res3)) {
26930 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26931 }
26932 arg3 = reinterpret_cast< wxMenu * >(argp3);
26933 }
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26937 wxPyEndAllowThreads(__tstate);
26938 if (PyErr_Occurred()) SWIG_fail;
26939 }
26940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 PyObject *resultobj = 0;
26949 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26950 int result;
26951 void *argp1 = 0 ;
26952 int res1 = 0 ;
26953 PyObject *swig_obj[1] ;
26954
26955 if (!args) SWIG_fail;
26956 swig_obj[0] = args;
26957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26960 }
26961 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26965 wxPyEndAllowThreads(__tstate);
26966 if (PyErr_Occurred()) SWIG_fail;
26967 }
26968 resultobj = SWIG_From_int(static_cast< int >(result));
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26976 PyObject *resultobj = 0;
26977 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26978 bool result;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 PyObject *swig_obj[1] ;
26982
26983 if (!args) SWIG_fail;
26984 swig_obj[0] = args;
26985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26986 if (!SWIG_IsOK(res1)) {
26987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26988 }
26989 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 {
26997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26998 }
26999 return resultobj;
27000 fail:
27001 return NULL;
27002 }
27003
27004
27005 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27006 PyObject *resultobj = 0;
27007 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27008 wxMenu *result = 0 ;
27009 void *argp1 = 0 ;
27010 int res1 = 0 ;
27011 PyObject *swig_obj[1] ;
27012
27013 if (!args) SWIG_fail;
27014 swig_obj[0] = args;
27015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27018 }
27019 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27020 {
27021 PyThreadState* __tstate = wxPyBeginAllowThreads();
27022 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27023 wxPyEndAllowThreads(__tstate);
27024 if (PyErr_Occurred()) SWIG_fail;
27025 }
27026 {
27027 resultobj = wxPyMake_wxObject(result, (bool)0);
27028 }
27029 return resultobj;
27030 fail:
27031 return NULL;
27032 }
27033
27034
27035 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27036 PyObject *obj;
27037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27038 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27039 return SWIG_Py_Void();
27040 }
27041
27042 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 return SWIG_Python_InitShadowInstance(args);
27044 }
27045
27046 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27047 PyObject *resultobj = 0;
27048 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27049 int arg2 = (int) 0 ;
27050 wxCloseEvent *result = 0 ;
27051 int val1 ;
27052 int ecode1 = 0 ;
27053 int val2 ;
27054 int ecode2 = 0 ;
27055 PyObject * obj0 = 0 ;
27056 PyObject * obj1 = 0 ;
27057 char * kwnames[] = {
27058 (char *) "type",(char *) "winid", NULL
27059 };
27060
27061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27062 if (obj0) {
27063 ecode1 = SWIG_AsVal_int(obj0, &val1);
27064 if (!SWIG_IsOK(ecode1)) {
27065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27066 }
27067 arg1 = static_cast< wxEventType >(val1);
27068 }
27069 if (obj1) {
27070 ecode2 = SWIG_AsVal_int(obj1, &val2);
27071 if (!SWIG_IsOK(ecode2)) {
27072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27073 }
27074 arg2 = static_cast< int >(val2);
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27090 PyObject *resultobj = 0;
27091 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27092 bool arg2 ;
27093 void *argp1 = 0 ;
27094 int res1 = 0 ;
27095 bool val2 ;
27096 int ecode2 = 0 ;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "logOff", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27107 }
27108 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27109 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27110 if (!SWIG_IsOK(ecode2)) {
27111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27112 }
27113 arg2 = static_cast< bool >(val2);
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 (arg1)->SetLoggingOff(arg2);
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 resultobj = SWIG_Py_Void();
27121 return resultobj;
27122 fail:
27123 return NULL;
27124 }
27125
27126
27127 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27128 PyObject *resultobj = 0;
27129 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27130 bool result;
27131 void *argp1 = 0 ;
27132 int res1 = 0 ;
27133 PyObject *swig_obj[1] ;
27134
27135 if (!args) SWIG_fail;
27136 swig_obj[0] = args;
27137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27138 if (!SWIG_IsOK(res1)) {
27139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27140 }
27141 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 {
27149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj = 0;
27159 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27160 bool arg2 = (bool) true ;
27161 void *argp1 = 0 ;
27162 int res1 = 0 ;
27163 bool val2 ;
27164 int ecode2 = 0 ;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 char * kwnames[] = {
27168 (char *) "self",(char *) "veto", NULL
27169 };
27170
27171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27173 if (!SWIG_IsOK(res1)) {
27174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27175 }
27176 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27177 if (obj1) {
27178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27179 if (!SWIG_IsOK(ecode2)) {
27180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27181 }
27182 arg2 = static_cast< bool >(val2);
27183 }
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 (arg1)->Veto(arg2);
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_Py_Void();
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27198 PyObject *resultobj = 0;
27199 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27200 bool result;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 PyObject *swig_obj[1] ;
27204
27205 if (!args) SWIG_fail;
27206 swig_obj[0] = args;
27207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27208 if (!SWIG_IsOK(res1)) {
27209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27210 }
27211 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 {
27219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27220 }
27221 return resultobj;
27222 fail:
27223 return NULL;
27224 }
27225
27226
27227 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27228 PyObject *resultobj = 0;
27229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27230 bool arg2 ;
27231 void *argp1 = 0 ;
27232 int res1 = 0 ;
27233 bool val2 ;
27234 int ecode2 = 0 ;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 char * kwnames[] = {
27238 (char *) "self",(char *) "canVeto", NULL
27239 };
27240
27241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27243 if (!SWIG_IsOK(res1)) {
27244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27245 }
27246 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27248 if (!SWIG_IsOK(ecode2)) {
27249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27250 }
27251 arg2 = static_cast< bool >(val2);
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 (arg1)->SetCanVeto(arg2);
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 resultobj = SWIG_Py_Void();
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27266 PyObject *resultobj = 0;
27267 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27268 bool result;
27269 void *argp1 = 0 ;
27270 int res1 = 0 ;
27271 PyObject *swig_obj[1] ;
27272
27273 if (!args) SWIG_fail;
27274 swig_obj[0] = args;
27275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27276 if (!SWIG_IsOK(res1)) {
27277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27278 }
27279 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27283 wxPyEndAllowThreads(__tstate);
27284 if (PyErr_Occurred()) SWIG_fail;
27285 }
27286 {
27287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27288 }
27289 return resultobj;
27290 fail:
27291 return NULL;
27292 }
27293
27294
27295 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27296 PyObject *obj;
27297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27298 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27299 return SWIG_Py_Void();
27300 }
27301
27302 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27303 return SWIG_Python_InitShadowInstance(args);
27304 }
27305
27306 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27307 PyObject *resultobj = 0;
27308 int arg1 = (int) 0 ;
27309 bool arg2 = (bool) false ;
27310 wxShowEvent *result = 0 ;
27311 int val1 ;
27312 int ecode1 = 0 ;
27313 bool val2 ;
27314 int ecode2 = 0 ;
27315 PyObject * obj0 = 0 ;
27316 PyObject * obj1 = 0 ;
27317 char * kwnames[] = {
27318 (char *) "winid",(char *) "show", NULL
27319 };
27320
27321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27322 if (obj0) {
27323 ecode1 = SWIG_AsVal_int(obj0, &val1);
27324 if (!SWIG_IsOK(ecode1)) {
27325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27326 }
27327 arg1 = static_cast< int >(val1);
27328 }
27329 if (obj1) {
27330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27331 if (!SWIG_IsOK(ecode2)) {
27332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27333 }
27334 arg2 = static_cast< bool >(val2);
27335 }
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27350 PyObject *resultobj = 0;
27351 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27352 bool arg2 ;
27353 void *argp1 = 0 ;
27354 int res1 = 0 ;
27355 bool val2 ;
27356 int ecode2 = 0 ;
27357 PyObject * obj0 = 0 ;
27358 PyObject * obj1 = 0 ;
27359 char * kwnames[] = {
27360 (char *) "self",(char *) "show", NULL
27361 };
27362
27363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27367 }
27368 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27370 if (!SWIG_IsOK(ecode2)) {
27371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27372 }
27373 arg2 = static_cast< bool >(val2);
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 (arg1)->SetShow(arg2);
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = SWIG_Py_Void();
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 PyObject *resultobj = 0;
27389 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27390 bool result;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 PyObject *swig_obj[1] ;
27394
27395 if (!args) SWIG_fail;
27396 swig_obj[0] = args;
27397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27398 if (!SWIG_IsOK(res1)) {
27399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27400 }
27401 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 {
27409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27410 }
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27418 PyObject *obj;
27419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27420 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27421 return SWIG_Py_Void();
27422 }
27423
27424 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27425 return SWIG_Python_InitShadowInstance(args);
27426 }
27427
27428 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27429 PyObject *resultobj = 0;
27430 int arg1 = (int) 0 ;
27431 bool arg2 = (bool) true ;
27432 wxIconizeEvent *result = 0 ;
27433 int val1 ;
27434 int ecode1 = 0 ;
27435 bool val2 ;
27436 int ecode2 = 0 ;
27437 PyObject * obj0 = 0 ;
27438 PyObject * obj1 = 0 ;
27439 char * kwnames[] = {
27440 (char *) "id",(char *) "iconized", NULL
27441 };
27442
27443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27444 if (obj0) {
27445 ecode1 = SWIG_AsVal_int(obj0, &val1);
27446 if (!SWIG_IsOK(ecode1)) {
27447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27448 }
27449 arg1 = static_cast< int >(val1);
27450 }
27451 if (obj1) {
27452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27453 if (!SWIG_IsOK(ecode2)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27455 }
27456 arg2 = static_cast< bool >(val2);
27457 }
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27472 PyObject *resultobj = 0;
27473 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27474 bool result;
27475 void *argp1 = 0 ;
27476 int res1 = 0 ;
27477 PyObject *swig_obj[1] ;
27478
27479 if (!args) SWIG_fail;
27480 swig_obj[0] = args;
27481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27482 if (!SWIG_IsOK(res1)) {
27483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27484 }
27485 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (bool)(arg1)->Iconized();
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 PyObject *obj;
27503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27504 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27505 return SWIG_Py_Void();
27506 }
27507
27508 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27509 return SWIG_Python_InitShadowInstance(args);
27510 }
27511
27512 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = 0;
27514 int arg1 = (int) 0 ;
27515 wxMaximizeEvent *result = 0 ;
27516 int val1 ;
27517 int ecode1 = 0 ;
27518 PyObject * obj0 = 0 ;
27519 char * kwnames[] = {
27520 (char *) "id", NULL
27521 };
27522
27523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27524 if (obj0) {
27525 ecode1 = SWIG_AsVal_int(obj0, &val1);
27526 if (!SWIG_IsOK(ecode1)) {
27527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27528 }
27529 arg1 = static_cast< int >(val1);
27530 }
27531 {
27532 PyThreadState* __tstate = wxPyBeginAllowThreads();
27533 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27534 wxPyEndAllowThreads(__tstate);
27535 if (PyErr_Occurred()) SWIG_fail;
27536 }
27537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27538 return resultobj;
27539 fail:
27540 return NULL;
27541 }
27542
27543
27544 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27545 PyObject *obj;
27546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27547 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27548 return SWIG_Py_Void();
27549 }
27550
27551 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27552 return SWIG_Python_InitShadowInstance(args);
27553 }
27554
27555 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27556 PyObject *resultobj = 0;
27557 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27558 wxPoint result;
27559 void *argp1 = 0 ;
27560 int res1 = 0 ;
27561 PyObject *swig_obj[1] ;
27562
27563 if (!args) SWIG_fail;
27564 swig_obj[0] = args;
27565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27566 if (!SWIG_IsOK(res1)) {
27567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27568 }
27569 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = (arg1)->GetPosition();
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27584 PyObject *resultobj = 0;
27585 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27586 int result;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 PyObject *swig_obj[1] ;
27590
27591 if (!args) SWIG_fail;
27592 swig_obj[0] = args;
27593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27596 }
27597 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (int)(arg1)->GetNumberOfFiles();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_From_int(static_cast< int >(result));
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27612 PyObject *resultobj = 0;
27613 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27614 PyObject *result = 0 ;
27615 void *argp1 = 0 ;
27616 int res1 = 0 ;
27617 PyObject *swig_obj[1] ;
27618
27619 if (!args) SWIG_fail;
27620 swig_obj[0] = args;
27621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27624 }
27625 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 resultobj = result;
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27640 PyObject *obj;
27641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27642 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27643 return SWIG_Py_Void();
27644 }
27645
27646 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27647 PyObject *resultobj = 0;
27648 int arg1 = (int) 0 ;
27649 wxUpdateUIEvent *result = 0 ;
27650 int val1 ;
27651 int ecode1 = 0 ;
27652 PyObject * obj0 = 0 ;
27653 char * kwnames[] = {
27654 (char *) "commandId", NULL
27655 };
27656
27657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27658 if (obj0) {
27659 ecode1 = SWIG_AsVal_int(obj0, &val1);
27660 if (!SWIG_IsOK(ecode1)) {
27661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27662 }
27663 arg1 = static_cast< int >(val1);
27664 }
27665 {
27666 PyThreadState* __tstate = wxPyBeginAllowThreads();
27667 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27668 wxPyEndAllowThreads(__tstate);
27669 if (PyErr_Occurred()) SWIG_fail;
27670 }
27671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27672 return resultobj;
27673 fail:
27674 return NULL;
27675 }
27676
27677
27678 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27679 PyObject *resultobj = 0;
27680 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27681 bool result;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 PyObject *swig_obj[1] ;
27685
27686 if (!args) SWIG_fail;
27687 swig_obj[0] = args;
27688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27689 if (!SWIG_IsOK(res1)) {
27690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27691 }
27692 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27696 wxPyEndAllowThreads(__tstate);
27697 if (PyErr_Occurred()) SWIG_fail;
27698 }
27699 {
27700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27701 }
27702 return resultobj;
27703 fail:
27704 return NULL;
27705 }
27706
27707
27708 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27709 PyObject *resultobj = 0;
27710 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27711 bool result;
27712 void *argp1 = 0 ;
27713 int res1 = 0 ;
27714 PyObject *swig_obj[1] ;
27715
27716 if (!args) SWIG_fail;
27717 swig_obj[0] = args;
27718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27719 if (!SWIG_IsOK(res1)) {
27720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27721 }
27722 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 {
27730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27731 }
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739 PyObject *resultobj = 0;
27740 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27741 bool result;
27742 void *argp1 = 0 ;
27743 int res1 = 0 ;
27744 PyObject *swig_obj[1] ;
27745
27746 if (!args) SWIG_fail;
27747 swig_obj[0] = args;
27748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27749 if (!SWIG_IsOK(res1)) {
27750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27751 }
27752 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 {
27760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27761 }
27762 return resultobj;
27763 fail:
27764 return NULL;
27765 }
27766
27767
27768 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27769 PyObject *resultobj = 0;
27770 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27771 wxString result;
27772 void *argp1 = 0 ;
27773 int res1 = 0 ;
27774 PyObject *swig_obj[1] ;
27775
27776 if (!args) SWIG_fail;
27777 swig_obj[0] = args;
27778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27779 if (!SWIG_IsOK(res1)) {
27780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27781 }
27782 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27783 {
27784 PyThreadState* __tstate = wxPyBeginAllowThreads();
27785 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 {
27790 #if wxUSE_UNICODE
27791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27792 #else
27793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27794 #endif
27795 }
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27803 PyObject *resultobj = 0;
27804 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27805 bool result;
27806 void *argp1 = 0 ;
27807 int res1 = 0 ;
27808 PyObject *swig_obj[1] ;
27809
27810 if (!args) SWIG_fail;
27811 swig_obj[0] = args;
27812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27813 if (!SWIG_IsOK(res1)) {
27814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27815 }
27816 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27817 {
27818 PyThreadState* __tstate = wxPyBeginAllowThreads();
27819 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 {
27824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27825 }
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27833 PyObject *resultobj = 0;
27834 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27835 bool result;
27836 void *argp1 = 0 ;
27837 int res1 = 0 ;
27838 PyObject *swig_obj[1] ;
27839
27840 if (!args) SWIG_fail;
27841 swig_obj[0] = args;
27842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27845 }
27846 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 {
27854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27855 }
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27863 PyObject *resultobj = 0;
27864 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27865 bool result;
27866 void *argp1 = 0 ;
27867 int res1 = 0 ;
27868 PyObject *swig_obj[1] ;
27869
27870 if (!args) SWIG_fail;
27871 swig_obj[0] = args;
27872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27873 if (!SWIG_IsOK(res1)) {
27874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27875 }
27876 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 {
27884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27885 }
27886 return resultobj;
27887 fail:
27888 return NULL;
27889 }
27890
27891
27892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27893 PyObject *resultobj = 0;
27894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27895 bool result;
27896 void *argp1 = 0 ;
27897 int res1 = 0 ;
27898 PyObject *swig_obj[1] ;
27899
27900 if (!args) SWIG_fail;
27901 swig_obj[0] = args;
27902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27903 if (!SWIG_IsOK(res1)) {
27904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27905 }
27906 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 {
27914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27915 }
27916 return resultobj;
27917 fail:
27918 return NULL;
27919 }
27920
27921
27922 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj = 0;
27924 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27925 bool arg2 ;
27926 void *argp1 = 0 ;
27927 int res1 = 0 ;
27928 bool val2 ;
27929 int ecode2 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 PyObject * obj1 = 0 ;
27932 char * kwnames[] = {
27933 (char *) "self",(char *) "check", NULL
27934 };
27935
27936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27938 if (!SWIG_IsOK(res1)) {
27939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27940 }
27941 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27942 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27943 if (!SWIG_IsOK(ecode2)) {
27944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27945 }
27946 arg2 = static_cast< bool >(val2);
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 (arg1)->Check(arg2);
27950 wxPyEndAllowThreads(__tstate);
27951 if (PyErr_Occurred()) SWIG_fail;
27952 }
27953 resultobj = SWIG_Py_Void();
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27961 PyObject *resultobj = 0;
27962 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27963 bool arg2 ;
27964 void *argp1 = 0 ;
27965 int res1 = 0 ;
27966 bool val2 ;
27967 int ecode2 = 0 ;
27968 PyObject * obj0 = 0 ;
27969 PyObject * obj1 = 0 ;
27970 char * kwnames[] = {
27971 (char *) "self",(char *) "enable", NULL
27972 };
27973
27974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27976 if (!SWIG_IsOK(res1)) {
27977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27978 }
27979 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27980 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27981 if (!SWIG_IsOK(ecode2)) {
27982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27983 }
27984 arg2 = static_cast< bool >(val2);
27985 {
27986 PyThreadState* __tstate = wxPyBeginAllowThreads();
27987 (arg1)->Enable(arg2);
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 resultobj = SWIG_Py_Void();
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj = 0;
28000 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28001 bool arg2 ;
28002 void *argp1 = 0 ;
28003 int res1 = 0 ;
28004 bool val2 ;
28005 int ecode2 = 0 ;
28006 PyObject * obj0 = 0 ;
28007 PyObject * obj1 = 0 ;
28008 char * kwnames[] = {
28009 (char *) "self",(char *) "show", NULL
28010 };
28011
28012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28016 }
28017 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28019 if (!SWIG_IsOK(ecode2)) {
28020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28021 }
28022 arg2 = static_cast< bool >(val2);
28023 {
28024 PyThreadState* __tstate = wxPyBeginAllowThreads();
28025 (arg1)->Show(arg2);
28026 wxPyEndAllowThreads(__tstate);
28027 if (PyErr_Occurred()) SWIG_fail;
28028 }
28029 resultobj = SWIG_Py_Void();
28030 return resultobj;
28031 fail:
28032 return NULL;
28033 }
28034
28035
28036 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28037 PyObject *resultobj = 0;
28038 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28039 wxString *arg2 = 0 ;
28040 void *argp1 = 0 ;
28041 int res1 = 0 ;
28042 bool temp2 = false ;
28043 PyObject * obj0 = 0 ;
28044 PyObject * obj1 = 0 ;
28045 char * kwnames[] = {
28046 (char *) "self",(char *) "text", NULL
28047 };
28048
28049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28053 }
28054 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28055 {
28056 arg2 = wxString_in_helper(obj1);
28057 if (arg2 == NULL) SWIG_fail;
28058 temp2 = true;
28059 }
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 (arg1)->SetText((wxString const &)*arg2);
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_Py_Void();
28067 {
28068 if (temp2)
28069 delete arg2;
28070 }
28071 return resultobj;
28072 fail:
28073 {
28074 if (temp2)
28075 delete arg2;
28076 }
28077 return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj = 0;
28083 long arg1 ;
28084 long val1 ;
28085 int ecode1 = 0 ;
28086 PyObject * obj0 = 0 ;
28087 char * kwnames[] = {
28088 (char *) "updateInterval", NULL
28089 };
28090
28091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28092 ecode1 = SWIG_AsVal_long(obj0, &val1);
28093 if (!SWIG_IsOK(ecode1)) {
28094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28095 }
28096 arg1 = static_cast< long >(val1);
28097 {
28098 PyThreadState* __tstate = wxPyBeginAllowThreads();
28099 wxUpdateUIEvent::SetUpdateInterval(arg1);
28100 wxPyEndAllowThreads(__tstate);
28101 if (PyErr_Occurred()) SWIG_fail;
28102 }
28103 resultobj = SWIG_Py_Void();
28104 return resultobj;
28105 fail:
28106 return NULL;
28107 }
28108
28109
28110 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28111 PyObject *resultobj = 0;
28112 long result;
28113
28114 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28115 {
28116 PyThreadState* __tstate = wxPyBeginAllowThreads();
28117 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28118 wxPyEndAllowThreads(__tstate);
28119 if (PyErr_Occurred()) SWIG_fail;
28120 }
28121 resultobj = SWIG_From_long(static_cast< long >(result));
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj = 0;
28130 wxWindow *arg1 = (wxWindow *) 0 ;
28131 bool result;
28132 void *argp1 = 0 ;
28133 int res1 = 0 ;
28134 PyObject * obj0 = 0 ;
28135 char * kwnames[] = {
28136 (char *) "win", NULL
28137 };
28138
28139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28141 if (!SWIG_IsOK(res1)) {
28142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28143 }
28144 arg1 = reinterpret_cast< wxWindow * >(argp1);
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 {
28152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28153 }
28154 return resultobj;
28155 fail:
28156 return NULL;
28157 }
28158
28159
28160 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28161 PyObject *resultobj = 0;
28162
28163 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 wxUpdateUIEvent::ResetUpdateTime();
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_Py_Void();
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj = 0;
28179 wxUpdateUIMode arg1 ;
28180 int val1 ;
28181 int ecode1 = 0 ;
28182 PyObject * obj0 = 0 ;
28183 char * kwnames[] = {
28184 (char *) "mode", NULL
28185 };
28186
28187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28188 ecode1 = SWIG_AsVal_int(obj0, &val1);
28189 if (!SWIG_IsOK(ecode1)) {
28190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28191 }
28192 arg1 = static_cast< wxUpdateUIMode >(val1);
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 wxUpdateUIEvent::SetMode(arg1);
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 resultobj = SWIG_Py_Void();
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28207 PyObject *resultobj = 0;
28208 wxUpdateUIMode result;
28209
28210 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 resultobj = SWIG_From_int(static_cast< int >(result));
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28225 PyObject *obj;
28226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28227 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28228 return SWIG_Py_Void();
28229 }
28230
28231 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28232 return SWIG_Python_InitShadowInstance(args);
28233 }
28234
28235 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28236 PyObject *resultobj = 0;
28237 wxSysColourChangedEvent *result = 0 ;
28238
28239 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28254 PyObject *obj;
28255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28256 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28257 return SWIG_Py_Void();
28258 }
28259
28260 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28261 return SWIG_Python_InitShadowInstance(args);
28262 }
28263
28264 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28265 PyObject *resultobj = 0;
28266 int arg1 = (int) 0 ;
28267 wxWindow *arg2 = (wxWindow *) NULL ;
28268 wxMouseCaptureChangedEvent *result = 0 ;
28269 int val1 ;
28270 int ecode1 = 0 ;
28271 void *argp2 = 0 ;
28272 int res2 = 0 ;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char * kwnames[] = {
28276 (char *) "winid",(char *) "gainedCapture", NULL
28277 };
28278
28279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28280 if (obj0) {
28281 ecode1 = SWIG_AsVal_int(obj0, &val1);
28282 if (!SWIG_IsOK(ecode1)) {
28283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28284 }
28285 arg1 = static_cast< int >(val1);
28286 }
28287 if (obj1) {
28288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28289 if (!SWIG_IsOK(res2)) {
28290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28291 }
28292 arg2 = reinterpret_cast< wxWindow * >(argp2);
28293 }
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28310 wxWindow *result = 0 ;
28311 void *argp1 = 0 ;
28312 int res1 = 0 ;
28313 PyObject *swig_obj[1] ;
28314
28315 if (!args) SWIG_fail;
28316 swig_obj[0] = args;
28317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28318 if (!SWIG_IsOK(res1)) {
28319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28320 }
28321 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 {
28329 resultobj = wxPyMake_wxObject(result, (bool)0);
28330 }
28331 return resultobj;
28332 fail:
28333 return NULL;
28334 }
28335
28336
28337 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28338 PyObject *obj;
28339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28340 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28341 return SWIG_Py_Void();
28342 }
28343
28344 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 return SWIG_Python_InitShadowInstance(args);
28346 }
28347
28348 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj = 0;
28350 int arg1 = (int) 0 ;
28351 wxMouseCaptureLostEvent *result = 0 ;
28352 int val1 ;
28353 int ecode1 = 0 ;
28354 PyObject * obj0 = 0 ;
28355 char * kwnames[] = {
28356 (char *) "winid", NULL
28357 };
28358
28359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28360 if (obj0) {
28361 ecode1 = SWIG_AsVal_int(obj0, &val1);
28362 if (!SWIG_IsOK(ecode1)) {
28363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28364 }
28365 arg1 = static_cast< int >(val1);
28366 }
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28381 PyObject *obj;
28382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28383 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28384 return SWIG_Py_Void();
28385 }
28386
28387 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28388 return SWIG_Python_InitShadowInstance(args);
28389 }
28390
28391 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *resultobj = 0;
28393 wxDisplayChangedEvent *result = 0 ;
28394
28395 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28410 PyObject *obj;
28411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28412 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28413 return SWIG_Py_Void();
28414 }
28415
28416 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28417 return SWIG_Python_InitShadowInstance(args);
28418 }
28419
28420 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28421 PyObject *resultobj = 0;
28422 int arg1 = (int) 0 ;
28423 wxPaletteChangedEvent *result = 0 ;
28424 int val1 ;
28425 int ecode1 = 0 ;
28426 PyObject * obj0 = 0 ;
28427 char * kwnames[] = {
28428 (char *) "id", NULL
28429 };
28430
28431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28432 if (obj0) {
28433 ecode1 = SWIG_AsVal_int(obj0, &val1);
28434 if (!SWIG_IsOK(ecode1)) {
28435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28436 }
28437 arg1 = static_cast< int >(val1);
28438 }
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28446 return resultobj;
28447 fail:
28448 return NULL;
28449 }
28450
28451
28452 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28453 PyObject *resultobj = 0;
28454 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28455 wxWindow *arg2 = (wxWindow *) 0 ;
28456 void *argp1 = 0 ;
28457 int res1 = 0 ;
28458 void *argp2 = 0 ;
28459 int res2 = 0 ;
28460 PyObject * obj0 = 0 ;
28461 PyObject * obj1 = 0 ;
28462 char * kwnames[] = {
28463 (char *) "self",(char *) "win", NULL
28464 };
28465
28466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28468 if (!SWIG_IsOK(res1)) {
28469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28470 }
28471 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28473 if (!SWIG_IsOK(res2)) {
28474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28475 }
28476 arg2 = reinterpret_cast< wxWindow * >(argp2);
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 (arg1)->SetChangedWindow(arg2);
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 resultobj = SWIG_Py_Void();
28484 return resultobj;
28485 fail:
28486 return NULL;
28487 }
28488
28489
28490 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28493 wxWindow *result = 0 ;
28494 void *argp1 = 0 ;
28495 int res1 = 0 ;
28496 PyObject *swig_obj[1] ;
28497
28498 if (!args) SWIG_fail;
28499 swig_obj[0] = args;
28500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28501 if (!SWIG_IsOK(res1)) {
28502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28503 }
28504 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (wxWindow *)(arg1)->GetChangedWindow();
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = wxPyMake_wxObject(result, (bool)0);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28521 PyObject *obj;
28522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28523 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28524 return SWIG_Py_Void();
28525 }
28526
28527 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28528 return SWIG_Python_InitShadowInstance(args);
28529 }
28530
28531 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28532 PyObject *resultobj = 0;
28533 int arg1 = (int) 0 ;
28534 wxQueryNewPaletteEvent *result = 0 ;
28535 int val1 ;
28536 int ecode1 = 0 ;
28537 PyObject * obj0 = 0 ;
28538 char * kwnames[] = {
28539 (char *) "winid", NULL
28540 };
28541
28542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28543 if (obj0) {
28544 ecode1 = SWIG_AsVal_int(obj0, &val1);
28545 if (!SWIG_IsOK(ecode1)) {
28546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28547 }
28548 arg1 = static_cast< int >(val1);
28549 }
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28564 PyObject *resultobj = 0;
28565 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28566 bool arg2 ;
28567 void *argp1 = 0 ;
28568 int res1 = 0 ;
28569 bool val2 ;
28570 int ecode2 = 0 ;
28571 PyObject * obj0 = 0 ;
28572 PyObject * obj1 = 0 ;
28573 char * kwnames[] = {
28574 (char *) "self",(char *) "realized", NULL
28575 };
28576
28577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28579 if (!SWIG_IsOK(res1)) {
28580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28581 }
28582 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28584 if (!SWIG_IsOK(ecode2)) {
28585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28586 }
28587 arg2 = static_cast< bool >(val2);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 (arg1)->SetPaletteRealized(arg2);
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 resultobj = SWIG_Py_Void();
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28602 PyObject *resultobj = 0;
28603 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28604 bool result;
28605 void *argp1 = 0 ;
28606 int res1 = 0 ;
28607 PyObject *swig_obj[1] ;
28608
28609 if (!args) SWIG_fail;
28610 swig_obj[0] = args;
28611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28612 if (!SWIG_IsOK(res1)) {
28613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28614 }
28615 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 {
28623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28624 }
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *obj;
28633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28634 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28635 return SWIG_Py_Void();
28636 }
28637
28638 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28639 return SWIG_Python_InitShadowInstance(args);
28640 }
28641
28642 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28643 PyObject *resultobj = 0;
28644 wxNavigationKeyEvent *result = 0 ;
28645
28646 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28647 {
28648 PyThreadState* __tstate = wxPyBeginAllowThreads();
28649 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28650 wxPyEndAllowThreads(__tstate);
28651 if (PyErr_Occurred()) SWIG_fail;
28652 }
28653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 PyObject *resultobj = 0;
28662 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28663 bool result;
28664 void *argp1 = 0 ;
28665 int res1 = 0 ;
28666 PyObject *swig_obj[1] ;
28667
28668 if (!args) SWIG_fail;
28669 swig_obj[0] = args;
28670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28673 }
28674 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 {
28682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28683 }
28684 return resultobj;
28685 fail:
28686 return NULL;
28687 }
28688
28689
28690 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28691 PyObject *resultobj = 0;
28692 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28693 bool arg2 ;
28694 void *argp1 = 0 ;
28695 int res1 = 0 ;
28696 bool val2 ;
28697 int ecode2 = 0 ;
28698 PyObject * obj0 = 0 ;
28699 PyObject * obj1 = 0 ;
28700 char * kwnames[] = {
28701 (char *) "self",(char *) "forward", NULL
28702 };
28703
28704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28706 if (!SWIG_IsOK(res1)) {
28707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28708 }
28709 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28711 if (!SWIG_IsOK(ecode2)) {
28712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28713 }
28714 arg2 = static_cast< bool >(val2);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 (arg1)->SetDirection(arg2);
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 resultobj = SWIG_Py_Void();
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28731 bool result;
28732 void *argp1 = 0 ;
28733 int res1 = 0 ;
28734 PyObject *swig_obj[1] ;
28735
28736 if (!args) SWIG_fail;
28737 swig_obj[0] = args;
28738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28741 }
28742 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 {
28750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28751 }
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj = 0;
28760 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28761 bool arg2 ;
28762 void *argp1 = 0 ;
28763 int res1 = 0 ;
28764 bool val2 ;
28765 int ecode2 = 0 ;
28766 PyObject * obj0 = 0 ;
28767 PyObject * obj1 = 0 ;
28768 char * kwnames[] = {
28769 (char *) "self",(char *) "ischange", NULL
28770 };
28771
28772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28774 if (!SWIG_IsOK(res1)) {
28775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28776 }
28777 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28779 if (!SWIG_IsOK(ecode2)) {
28780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28781 }
28782 arg2 = static_cast< bool >(val2);
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 (arg1)->SetWindowChange(arg2);
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_Py_Void();
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28799 bool result;
28800 void *argp1 = 0 ;
28801 int res1 = 0 ;
28802 PyObject *swig_obj[1] ;
28803
28804 if (!args) SWIG_fail;
28805 swig_obj[0] = args;
28806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28809 }
28810 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28819 }
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj = 0;
28828 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28829 bool arg2 ;
28830 void *argp1 = 0 ;
28831 int res1 = 0 ;
28832 bool val2 ;
28833 int ecode2 = 0 ;
28834 PyObject * obj0 = 0 ;
28835 PyObject * obj1 = 0 ;
28836 char * kwnames[] = {
28837 (char *) "self",(char *) "bIs", NULL
28838 };
28839
28840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28842 if (!SWIG_IsOK(res1)) {
28843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28844 }
28845 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28847 if (!SWIG_IsOK(ecode2)) {
28848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28849 }
28850 arg2 = static_cast< bool >(val2);
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 (arg1)->SetFromTab(arg2);
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 resultobj = SWIG_Py_Void();
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28865 PyObject *resultobj = 0;
28866 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28867 long arg2 ;
28868 void *argp1 = 0 ;
28869 int res1 = 0 ;
28870 long val2 ;
28871 int ecode2 = 0 ;
28872 PyObject * obj0 = 0 ;
28873 PyObject * obj1 = 0 ;
28874 char * kwnames[] = {
28875 (char *) "self",(char *) "flags", NULL
28876 };
28877
28878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28880 if (!SWIG_IsOK(res1)) {
28881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28882 }
28883 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28884 ecode2 = SWIG_AsVal_long(obj1, &val2);
28885 if (!SWIG_IsOK(ecode2)) {
28886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28887 }
28888 arg2 = static_cast< long >(val2);
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 (arg1)->SetFlags(arg2);
28892 wxPyEndAllowThreads(__tstate);
28893 if (PyErr_Occurred()) SWIG_fail;
28894 }
28895 resultobj = SWIG_Py_Void();
28896 return resultobj;
28897 fail:
28898 return NULL;
28899 }
28900
28901
28902 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28903 PyObject *resultobj = 0;
28904 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28905 wxWindow *result = 0 ;
28906 void *argp1 = 0 ;
28907 int res1 = 0 ;
28908 PyObject *swig_obj[1] ;
28909
28910 if (!args) SWIG_fail;
28911 swig_obj[0] = args;
28912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28913 if (!SWIG_IsOK(res1)) {
28914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28915 }
28916 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 {
28924 resultobj = wxPyMake_wxObject(result, (bool)0);
28925 }
28926 return resultobj;
28927 fail:
28928 return NULL;
28929 }
28930
28931
28932 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28933 PyObject *resultobj = 0;
28934 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28935 wxWindow *arg2 = (wxWindow *) 0 ;
28936 void *argp1 = 0 ;
28937 int res1 = 0 ;
28938 void *argp2 = 0 ;
28939 int res2 = 0 ;
28940 PyObject * obj0 = 0 ;
28941 PyObject * obj1 = 0 ;
28942 char * kwnames[] = {
28943 (char *) "self",(char *) "win", NULL
28944 };
28945
28946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28948 if (!SWIG_IsOK(res1)) {
28949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28950 }
28951 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28953 if (!SWIG_IsOK(res2)) {
28954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28955 }
28956 arg2 = reinterpret_cast< wxWindow * >(argp2);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 (arg1)->SetCurrentFocus(arg2);
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 resultobj = SWIG_Py_Void();
28964 return resultobj;
28965 fail:
28966 return NULL;
28967 }
28968
28969
28970 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28971 PyObject *obj;
28972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28973 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28974 return SWIG_Py_Void();
28975 }
28976
28977 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28978 return SWIG_Python_InitShadowInstance(args);
28979 }
28980
28981 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28982 PyObject *resultobj = 0;
28983 wxWindow *arg1 = (wxWindow *) NULL ;
28984 wxWindowCreateEvent *result = 0 ;
28985 void *argp1 = 0 ;
28986 int res1 = 0 ;
28987 PyObject * obj0 = 0 ;
28988 char * kwnames[] = {
28989 (char *) "win", NULL
28990 };
28991
28992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28993 if (obj0) {
28994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28995 if (!SWIG_IsOK(res1)) {
28996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
28997 }
28998 arg1 = reinterpret_cast< wxWindow * >(argp1);
28999 }
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29003 wxPyEndAllowThreads(__tstate);
29004 if (PyErr_Occurred()) SWIG_fail;
29005 }
29006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29007 return resultobj;
29008 fail:
29009 return NULL;
29010 }
29011
29012
29013 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29014 PyObject *resultobj = 0;
29015 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29016 wxWindow *result = 0 ;
29017 void *argp1 = 0 ;
29018 int res1 = 0 ;
29019 PyObject *swig_obj[1] ;
29020
29021 if (!args) SWIG_fail;
29022 swig_obj[0] = args;
29023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29024 if (!SWIG_IsOK(res1)) {
29025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29026 }
29027 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29031 wxPyEndAllowThreads(__tstate);
29032 if (PyErr_Occurred()) SWIG_fail;
29033 }
29034 {
29035 resultobj = wxPyMake_wxObject(result, (bool)0);
29036 }
29037 return resultobj;
29038 fail:
29039 return NULL;
29040 }
29041
29042
29043 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29044 PyObject *obj;
29045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29046 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29047 return SWIG_Py_Void();
29048 }
29049
29050 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 return SWIG_Python_InitShadowInstance(args);
29052 }
29053
29054 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29055 PyObject *resultobj = 0;
29056 wxWindow *arg1 = (wxWindow *) NULL ;
29057 wxWindowDestroyEvent *result = 0 ;
29058 void *argp1 = 0 ;
29059 int res1 = 0 ;
29060 PyObject * obj0 = 0 ;
29061 char * kwnames[] = {
29062 (char *) "win", NULL
29063 };
29064
29065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29066 if (obj0) {
29067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29068 if (!SWIG_IsOK(res1)) {
29069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29070 }
29071 arg1 = reinterpret_cast< wxWindow * >(argp1);
29072 }
29073 {
29074 PyThreadState* __tstate = wxPyBeginAllowThreads();
29075 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29080 return resultobj;
29081 fail:
29082 return NULL;
29083 }
29084
29085
29086 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29087 PyObject *resultobj = 0;
29088 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29089 wxWindow *result = 0 ;
29090 void *argp1 = 0 ;
29091 int res1 = 0 ;
29092 PyObject *swig_obj[1] ;
29093
29094 if (!args) SWIG_fail;
29095 swig_obj[0] = args;
29096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29097 if (!SWIG_IsOK(res1)) {
29098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29099 }
29100 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29101 {
29102 PyThreadState* __tstate = wxPyBeginAllowThreads();
29103 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 resultobj = wxPyMake_wxObject(result, (bool)0);
29109 }
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 PyObject *obj;
29118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29119 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29120 return SWIG_Py_Void();
29121 }
29122
29123 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 return SWIG_Python_InitShadowInstance(args);
29125 }
29126
29127 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj = 0;
29129 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29130 int arg2 = (int) 0 ;
29131 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29132 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29133 wxContextMenuEvent *result = 0 ;
29134 int val1 ;
29135 int ecode1 = 0 ;
29136 int val2 ;
29137 int ecode2 = 0 ;
29138 wxPoint temp3 ;
29139 PyObject * obj0 = 0 ;
29140 PyObject * obj1 = 0 ;
29141 PyObject * obj2 = 0 ;
29142 char * kwnames[] = {
29143 (char *) "type",(char *) "winid",(char *) "pt", NULL
29144 };
29145
29146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29147 if (obj0) {
29148 ecode1 = SWIG_AsVal_int(obj0, &val1);
29149 if (!SWIG_IsOK(ecode1)) {
29150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29151 }
29152 arg1 = static_cast< wxEventType >(val1);
29153 }
29154 if (obj1) {
29155 ecode2 = SWIG_AsVal_int(obj1, &val2);
29156 if (!SWIG_IsOK(ecode2)) {
29157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29158 }
29159 arg2 = static_cast< int >(val2);
29160 }
29161 if (obj2) {
29162 {
29163 arg3 = &temp3;
29164 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29165 }
29166 }
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29181 PyObject *resultobj = 0;
29182 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29183 wxPoint *result = 0 ;
29184 void *argp1 = 0 ;
29185 int res1 = 0 ;
29186 PyObject *swig_obj[1] ;
29187
29188 if (!args) SWIG_fail;
29189 swig_obj[0] = args;
29190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29191 if (!SWIG_IsOK(res1)) {
29192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29193 }
29194 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 {
29198 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29199 result = (wxPoint *) &_result_ref;
29200 }
29201 wxPyEndAllowThreads(__tstate);
29202 if (PyErr_Occurred()) SWIG_fail;
29203 }
29204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj = 0;
29213 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29214 wxPoint *arg2 = 0 ;
29215 void *argp1 = 0 ;
29216 int res1 = 0 ;
29217 wxPoint temp2 ;
29218 PyObject * obj0 = 0 ;
29219 PyObject * obj1 = 0 ;
29220 char * kwnames[] = {
29221 (char *) "self",(char *) "pos", NULL
29222 };
29223
29224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29226 if (!SWIG_IsOK(res1)) {
29227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29228 }
29229 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29230 {
29231 arg2 = &temp2;
29232 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29233 }
29234 {
29235 PyThreadState* __tstate = wxPyBeginAllowThreads();
29236 (arg1)->SetPosition((wxPoint const &)*arg2);
29237 wxPyEndAllowThreads(__tstate);
29238 if (PyErr_Occurred()) SWIG_fail;
29239 }
29240 resultobj = SWIG_Py_Void();
29241 return resultobj;
29242 fail:
29243 return NULL;
29244 }
29245
29246
29247 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29248 PyObject *obj;
29249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29250 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29251 return SWIG_Py_Void();
29252 }
29253
29254 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29255 return SWIG_Python_InitShadowInstance(args);
29256 }
29257
29258 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 PyObject *resultobj = 0;
29260 wxIdleEvent *result = 0 ;
29261
29262 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29263 {
29264 PyThreadState* __tstate = wxPyBeginAllowThreads();
29265 result = (wxIdleEvent *)new wxIdleEvent();
29266 wxPyEndAllowThreads(__tstate);
29267 if (PyErr_Occurred()) SWIG_fail;
29268 }
29269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29277 PyObject *resultobj = 0;
29278 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29279 bool arg2 = (bool) true ;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 bool val2 ;
29283 int ecode2 = 0 ;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 char * kwnames[] = {
29287 (char *) "self",(char *) "needMore", NULL
29288 };
29289
29290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29292 if (!SWIG_IsOK(res1)) {
29293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29294 }
29295 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29296 if (obj1) {
29297 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29298 if (!SWIG_IsOK(ecode2)) {
29299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29300 }
29301 arg2 = static_cast< bool >(val2);
29302 }
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 (arg1)->RequestMore(arg2);
29306 wxPyEndAllowThreads(__tstate);
29307 if (PyErr_Occurred()) SWIG_fail;
29308 }
29309 resultobj = SWIG_Py_Void();
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29317 PyObject *resultobj = 0;
29318 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29319 bool result;
29320 void *argp1 = 0 ;
29321 int res1 = 0 ;
29322 PyObject *swig_obj[1] ;
29323
29324 if (!args) SWIG_fail;
29325 swig_obj[0] = args;
29326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29327 if (!SWIG_IsOK(res1)) {
29328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29329 }
29330 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 {
29338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29339 }
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29347 PyObject *resultobj = 0;
29348 wxIdleMode arg1 ;
29349 int val1 ;
29350 int ecode1 = 0 ;
29351 PyObject * obj0 = 0 ;
29352 char * kwnames[] = {
29353 (char *) "mode", NULL
29354 };
29355
29356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29357 ecode1 = SWIG_AsVal_int(obj0, &val1);
29358 if (!SWIG_IsOK(ecode1)) {
29359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29360 }
29361 arg1 = static_cast< wxIdleMode >(val1);
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 wxIdleEvent::SetMode(arg1);
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_Py_Void();
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29376 PyObject *resultobj = 0;
29377 wxIdleMode result;
29378
29379 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 result = (wxIdleMode)wxIdleEvent::GetMode();
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_From_int(static_cast< int >(result));
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj = 0;
29395 wxWindow *arg1 = (wxWindow *) 0 ;
29396 bool result;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 PyObject * obj0 = 0 ;
29400 char * kwnames[] = {
29401 (char *) "win", NULL
29402 };
29403
29404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29406 if (!SWIG_IsOK(res1)) {
29407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29408 }
29409 arg1 = reinterpret_cast< wxWindow * >(argp1);
29410 {
29411 PyThreadState* __tstate = wxPyBeginAllowThreads();
29412 result = (bool)wxIdleEvent::CanSend(arg1);
29413 wxPyEndAllowThreads(__tstate);
29414 if (PyErr_Occurred()) SWIG_fail;
29415 }
29416 {
29417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29418 }
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29426 PyObject *obj;
29427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29428 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29429 return SWIG_Py_Void();
29430 }
29431
29432 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29433 return SWIG_Python_InitShadowInstance(args);
29434 }
29435
29436 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29437 PyObject *resultobj = 0;
29438 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29439 int arg2 = (int) 0 ;
29440 wxClipboardTextEvent *result = 0 ;
29441 int val1 ;
29442 int ecode1 = 0 ;
29443 int val2 ;
29444 int ecode2 = 0 ;
29445 PyObject * obj0 = 0 ;
29446 PyObject * obj1 = 0 ;
29447 char * kwnames[] = {
29448 (char *) "type",(char *) "winid", NULL
29449 };
29450
29451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29452 if (obj0) {
29453 ecode1 = SWIG_AsVal_int(obj0, &val1);
29454 if (!SWIG_IsOK(ecode1)) {
29455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29456 }
29457 arg1 = static_cast< wxEventType >(val1);
29458 }
29459 if (obj1) {
29460 ecode2 = SWIG_AsVal_int(obj1, &val2);
29461 if (!SWIG_IsOK(ecode2)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29463 }
29464 arg2 = static_cast< int >(val2);
29465 }
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29469 wxPyEndAllowThreads(__tstate);
29470 if (PyErr_Occurred()) SWIG_fail;
29471 }
29472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29480 PyObject *obj;
29481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29482 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29483 return SWIG_Py_Void();
29484 }
29485
29486 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29487 return SWIG_Python_InitShadowInstance(args);
29488 }
29489
29490 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29491 PyObject *resultobj = 0;
29492 int arg1 = (int) 0 ;
29493 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29494 wxPyEvent *result = 0 ;
29495 int val1 ;
29496 int ecode1 = 0 ;
29497 int val2 ;
29498 int ecode2 = 0 ;
29499 PyObject * obj0 = 0 ;
29500 PyObject * obj1 = 0 ;
29501 char * kwnames[] = {
29502 (char *) "winid",(char *) "eventType", NULL
29503 };
29504
29505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29506 if (obj0) {
29507 ecode1 = SWIG_AsVal_int(obj0, &val1);
29508 if (!SWIG_IsOK(ecode1)) {
29509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29510 }
29511 arg1 = static_cast< int >(val1);
29512 }
29513 if (obj1) {
29514 ecode2 = SWIG_AsVal_int(obj1, &val2);
29515 if (!SWIG_IsOK(ecode2)) {
29516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29517 }
29518 arg2 = static_cast< wxEventType >(val2);
29519 }
29520 {
29521 PyThreadState* __tstate = wxPyBeginAllowThreads();
29522 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29523 wxPyEndAllowThreads(__tstate);
29524 if (PyErr_Occurred()) SWIG_fail;
29525 }
29526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29527 return resultobj;
29528 fail:
29529 return NULL;
29530 }
29531
29532
29533 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29534 PyObject *resultobj = 0;
29535 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29536 void *argp1 = 0 ;
29537 int res1 = 0 ;
29538 PyObject *swig_obj[1] ;
29539
29540 if (!args) SWIG_fail;
29541 swig_obj[0] = args;
29542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29543 if (!SWIG_IsOK(res1)) {
29544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29545 }
29546 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29547 {
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 delete arg1;
29550
29551 wxPyEndAllowThreads(__tstate);
29552 if (PyErr_Occurred()) SWIG_fail;
29553 }
29554 resultobj = SWIG_Py_Void();
29555 return resultobj;
29556 fail:
29557 return NULL;
29558 }
29559
29560
29561 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj = 0;
29563 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29564 PyObject *arg2 = (PyObject *) 0 ;
29565 void *argp1 = 0 ;
29566 int res1 = 0 ;
29567 PyObject * obj0 = 0 ;
29568 PyObject * obj1 = 0 ;
29569 char * kwnames[] = {
29570 (char *) "self",(char *) "self", NULL
29571 };
29572
29573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29575 if (!SWIG_IsOK(res1)) {
29576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29577 }
29578 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29579 arg2 = obj1;
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 (arg1)->SetSelf(arg2);
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 resultobj = SWIG_Py_Void();
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29594 PyObject *resultobj = 0;
29595 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29596 PyObject *result = 0 ;
29597 void *argp1 = 0 ;
29598 int res1 = 0 ;
29599 PyObject *swig_obj[1] ;
29600
29601 if (!args) SWIG_fail;
29602 swig_obj[0] = args;
29603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29604 if (!SWIG_IsOK(res1)) {
29605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29606 }
29607 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 result = (PyObject *)(arg1)->GetSelf();
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 resultobj = result;
29615 return resultobj;
29616 fail:
29617 return NULL;
29618 }
29619
29620
29621 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29622 PyObject *obj;
29623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29624 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29625 return SWIG_Py_Void();
29626 }
29627
29628 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29629 return SWIG_Python_InitShadowInstance(args);
29630 }
29631
29632 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29633 PyObject *resultobj = 0;
29634 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29635 int arg2 = (int) 0 ;
29636 wxPyCommandEvent *result = 0 ;
29637 int val1 ;
29638 int ecode1 = 0 ;
29639 int val2 ;
29640 int ecode2 = 0 ;
29641 PyObject * obj0 = 0 ;
29642 PyObject * obj1 = 0 ;
29643 char * kwnames[] = {
29644 (char *) "eventType",(char *) "id", NULL
29645 };
29646
29647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29648 if (obj0) {
29649 ecode1 = SWIG_AsVal_int(obj0, &val1);
29650 if (!SWIG_IsOK(ecode1)) {
29651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29652 }
29653 arg1 = static_cast< wxEventType >(val1);
29654 }
29655 if (obj1) {
29656 ecode2 = SWIG_AsVal_int(obj1, &val2);
29657 if (!SWIG_IsOK(ecode2)) {
29658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29659 }
29660 arg2 = static_cast< int >(val2);
29661 }
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29676 PyObject *resultobj = 0;
29677 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29678 void *argp1 = 0 ;
29679 int res1 = 0 ;
29680 PyObject *swig_obj[1] ;
29681
29682 if (!args) SWIG_fail;
29683 swig_obj[0] = args;
29684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29685 if (!SWIG_IsOK(res1)) {
29686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29687 }
29688 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 delete arg1;
29692
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 resultobj = SWIG_Py_Void();
29697 return resultobj;
29698 fail:
29699 return NULL;
29700 }
29701
29702
29703 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29704 PyObject *resultobj = 0;
29705 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29706 PyObject *arg2 = (PyObject *) 0 ;
29707 void *argp1 = 0 ;
29708 int res1 = 0 ;
29709 PyObject * obj0 = 0 ;
29710 PyObject * obj1 = 0 ;
29711 char * kwnames[] = {
29712 (char *) "self",(char *) "self", NULL
29713 };
29714
29715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29719 }
29720 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29721 arg2 = obj1;
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 (arg1)->SetSelf(arg2);
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 resultobj = SWIG_Py_Void();
29729 return resultobj;
29730 fail:
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29736 PyObject *resultobj = 0;
29737 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29738 PyObject *result = 0 ;
29739 void *argp1 = 0 ;
29740 int res1 = 0 ;
29741 PyObject *swig_obj[1] ;
29742
29743 if (!args) SWIG_fail;
29744 swig_obj[0] = args;
29745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29748 }
29749 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (PyObject *)(arg1)->GetSelf();
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = result;
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *obj;
29765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29767 return SWIG_Py_Void();
29768 }
29769
29770 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29771 return SWIG_Python_InitShadowInstance(args);
29772 }
29773
29774 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29775 PyObject *resultobj = 0;
29776 wxWindow *arg1 = (wxWindow *) 0 ;
29777 wxDateTime *arg2 = 0 ;
29778 wxEventType arg3 ;
29779 wxDateEvent *result = 0 ;
29780 void *argp1 = 0 ;
29781 int res1 = 0 ;
29782 void *argp2 = 0 ;
29783 int res2 = 0 ;
29784 int val3 ;
29785 int ecode3 = 0 ;
29786 PyObject * obj0 = 0 ;
29787 PyObject * obj1 = 0 ;
29788 PyObject * obj2 = 0 ;
29789 char * kwnames[] = {
29790 (char *) "win",(char *) "dt",(char *) "type", NULL
29791 };
29792
29793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29795 if (!SWIG_IsOK(res1)) {
29796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29797 }
29798 arg1 = reinterpret_cast< wxWindow * >(argp1);
29799 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29800 if (!SWIG_IsOK(res2)) {
29801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29802 }
29803 if (!argp2) {
29804 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29805 }
29806 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29807 ecode3 = SWIG_AsVal_int(obj2, &val3);
29808 if (!SWIG_IsOK(ecode3)) {
29809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29810 }
29811 arg3 = static_cast< wxEventType >(val3);
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29826 PyObject *resultobj = 0;
29827 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29828 wxDateTime *result = 0 ;
29829 void *argp1 = 0 ;
29830 int res1 = 0 ;
29831 PyObject *swig_obj[1] ;
29832
29833 if (!args) SWIG_fail;
29834 swig_obj[0] = args;
29835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29836 if (!SWIG_IsOK(res1)) {
29837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29838 }
29839 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29840 {
29841 PyThreadState* __tstate = wxPyBeginAllowThreads();
29842 {
29843 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29844 result = (wxDateTime *) &_result_ref;
29845 }
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29850 return resultobj;
29851 fail:
29852 return NULL;
29853 }
29854
29855
29856 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29857 PyObject *resultobj = 0;
29858 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29859 wxDateTime *arg2 = 0 ;
29860 void *argp1 = 0 ;
29861 int res1 = 0 ;
29862 void *argp2 = 0 ;
29863 int res2 = 0 ;
29864 PyObject * obj0 = 0 ;
29865 PyObject * obj1 = 0 ;
29866 char * kwnames[] = {
29867 (char *) "self",(char *) "date", NULL
29868 };
29869
29870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29872 if (!SWIG_IsOK(res1)) {
29873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29874 }
29875 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29877 if (!SWIG_IsOK(res2)) {
29878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29879 }
29880 if (!argp2) {
29881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29882 }
29883 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 (arg1)->SetDate((wxDateTime const &)*arg2);
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 resultobj = SWIG_Py_Void();
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29898 PyObject *obj;
29899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29900 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29901 return SWIG_Py_Void();
29902 }
29903
29904 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29905 return SWIG_Python_InitShadowInstance(args);
29906 }
29907
29908 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29909 PyObject *resultobj = 0;
29910 wxPyApp *result = 0 ;
29911
29912 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 result = (wxPyApp *)new_wxPyApp();
29916 wxPyEndAllowThreads(__tstate);
29917 if (PyErr_Occurred()) SWIG_fail;
29918 }
29919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29920 return resultobj;
29921 fail:
29922 return NULL;
29923 }
29924
29925
29926 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29927 PyObject *resultobj = 0;
29928 wxPyApp *arg1 = (wxPyApp *) 0 ;
29929 void *argp1 = 0 ;
29930 int res1 = 0 ;
29931 PyObject *swig_obj[1] ;
29932
29933 if (!args) SWIG_fail;
29934 swig_obj[0] = args;
29935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29936 if (!SWIG_IsOK(res1)) {
29937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29938 }
29939 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 delete arg1;
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 resultobj = SWIG_Py_Void();
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = 0;
29956 wxPyApp *arg1 = (wxPyApp *) 0 ;
29957 PyObject *arg2 = (PyObject *) 0 ;
29958 PyObject *arg3 = (PyObject *) 0 ;
29959 bool arg4 = (bool) false ;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 bool val4 ;
29963 int ecode4 = 0 ;
29964 PyObject * obj0 = 0 ;
29965 PyObject * obj1 = 0 ;
29966 PyObject * obj2 = 0 ;
29967 PyObject * obj3 = 0 ;
29968 char * kwnames[] = {
29969 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29970 };
29971
29972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29974 if (!SWIG_IsOK(res1)) {
29975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29976 }
29977 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29978 arg2 = obj1;
29979 arg3 = obj2;
29980 if (obj3) {
29981 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29982 if (!SWIG_IsOK(ecode4)) {
29983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29984 }
29985 arg4 = static_cast< bool >(val4);
29986 }
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29990 wxPyEndAllowThreads(__tstate);
29991 if (PyErr_Occurred()) SWIG_fail;
29992 }
29993 resultobj = SWIG_Py_Void();
29994 return resultobj;
29995 fail:
29996 return NULL;
29997 }
29998
29999
30000 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30001 PyObject *resultobj = 0;
30002 wxPyApp *arg1 = (wxPyApp *) 0 ;
30003 wxString result;
30004 void *argp1 = 0 ;
30005 int res1 = 0 ;
30006 PyObject *swig_obj[1] ;
30007
30008 if (!args) SWIG_fail;
30009 swig_obj[0] = args;
30010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30011 if (!SWIG_IsOK(res1)) {
30012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30013 }
30014 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = ((wxPyApp const *)arg1)->GetAppName();
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 {
30022 #if wxUSE_UNICODE
30023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30024 #else
30025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30026 #endif
30027 }
30028 return resultobj;
30029 fail:
30030 return NULL;
30031 }
30032
30033
30034 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30035 PyObject *resultobj = 0;
30036 wxPyApp *arg1 = (wxPyApp *) 0 ;
30037 wxString *arg2 = 0 ;
30038 void *argp1 = 0 ;
30039 int res1 = 0 ;
30040 bool temp2 = false ;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 char * kwnames[] = {
30044 (char *) "self",(char *) "name", NULL
30045 };
30046
30047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30049 if (!SWIG_IsOK(res1)) {
30050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30051 }
30052 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30053 {
30054 arg2 = wxString_in_helper(obj1);
30055 if (arg2 == NULL) SWIG_fail;
30056 temp2 = true;
30057 }
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 (arg1)->SetAppName((wxString const &)*arg2);
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 resultobj = SWIG_Py_Void();
30065 {
30066 if (temp2)
30067 delete arg2;
30068 }
30069 return resultobj;
30070 fail:
30071 {
30072 if (temp2)
30073 delete arg2;
30074 }
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30080 PyObject *resultobj = 0;
30081 wxPyApp *arg1 = (wxPyApp *) 0 ;
30082 wxString result;
30083 void *argp1 = 0 ;
30084 int res1 = 0 ;
30085 PyObject *swig_obj[1] ;
30086
30087 if (!args) SWIG_fail;
30088 swig_obj[0] = args;
30089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30090 if (!SWIG_IsOK(res1)) {
30091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30092 }
30093 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 result = ((wxPyApp const *)arg1)->GetClassName();
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 {
30101 #if wxUSE_UNICODE
30102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30103 #else
30104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30105 #endif
30106 }
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj = 0;
30115 wxPyApp *arg1 = (wxPyApp *) 0 ;
30116 wxString *arg2 = 0 ;
30117 void *argp1 = 0 ;
30118 int res1 = 0 ;
30119 bool temp2 = false ;
30120 PyObject * obj0 = 0 ;
30121 PyObject * obj1 = 0 ;
30122 char * kwnames[] = {
30123 (char *) "self",(char *) "name", NULL
30124 };
30125
30126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30128 if (!SWIG_IsOK(res1)) {
30129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30130 }
30131 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30132 {
30133 arg2 = wxString_in_helper(obj1);
30134 if (arg2 == NULL) SWIG_fail;
30135 temp2 = true;
30136 }
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 (arg1)->SetClassName((wxString const &)*arg2);
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 resultobj = SWIG_Py_Void();
30144 {
30145 if (temp2)
30146 delete arg2;
30147 }
30148 return resultobj;
30149 fail:
30150 {
30151 if (temp2)
30152 delete arg2;
30153 }
30154 return NULL;
30155 }
30156
30157
30158 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30159 PyObject *resultobj = 0;
30160 wxPyApp *arg1 = (wxPyApp *) 0 ;
30161 wxString *result = 0 ;
30162 void *argp1 = 0 ;
30163 int res1 = 0 ;
30164 PyObject *swig_obj[1] ;
30165
30166 if (!args) SWIG_fail;
30167 swig_obj[0] = args;
30168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30169 if (!SWIG_IsOK(res1)) {
30170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30171 }
30172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30173 {
30174 PyThreadState* __tstate = wxPyBeginAllowThreads();
30175 {
30176 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30177 result = (wxString *) &_result_ref;
30178 }
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 #if wxUSE_UNICODE
30184 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30185 #else
30186 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30187 #endif
30188 }
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj = 0;
30197 wxPyApp *arg1 = (wxPyApp *) 0 ;
30198 wxString *arg2 = 0 ;
30199 void *argp1 = 0 ;
30200 int res1 = 0 ;
30201 bool temp2 = false ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "name", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30212 }
30213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30214 {
30215 arg2 = wxString_in_helper(obj1);
30216 if (arg2 == NULL) SWIG_fail;
30217 temp2 = true;
30218 }
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 (arg1)->SetVendorName((wxString const &)*arg2);
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 resultobj = SWIG_Py_Void();
30226 {
30227 if (temp2)
30228 delete arg2;
30229 }
30230 return resultobj;
30231 fail:
30232 {
30233 if (temp2)
30234 delete arg2;
30235 }
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30241 PyObject *resultobj = 0;
30242 wxPyApp *arg1 = (wxPyApp *) 0 ;
30243 wxAppTraits *result = 0 ;
30244 void *argp1 = 0 ;
30245 int res1 = 0 ;
30246 PyObject *swig_obj[1] ;
30247
30248 if (!args) SWIG_fail;
30249 swig_obj[0] = args;
30250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30251 if (!SWIG_IsOK(res1)) {
30252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30253 }
30254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (wxAppTraits *)(arg1)->GetTraits();
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30269 PyObject *resultobj = 0;
30270 wxPyApp *arg1 = (wxPyApp *) 0 ;
30271 void *argp1 = 0 ;
30272 int res1 = 0 ;
30273 PyObject *swig_obj[1] ;
30274
30275 if (!args) SWIG_fail;
30276 swig_obj[0] = args;
30277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30278 if (!SWIG_IsOK(res1)) {
30279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30280 }
30281 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 (arg1)->ProcessPendingEvents();
30285 wxPyEndAllowThreads(__tstate);
30286 if (PyErr_Occurred()) SWIG_fail;
30287 }
30288 resultobj = SWIG_Py_Void();
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30296 PyObject *resultobj = 0;
30297 wxPyApp *arg1 = (wxPyApp *) 0 ;
30298 bool arg2 = (bool) false ;
30299 bool result;
30300 void *argp1 = 0 ;
30301 int res1 = 0 ;
30302 bool val2 ;
30303 int ecode2 = 0 ;
30304 PyObject * obj0 = 0 ;
30305 PyObject * obj1 = 0 ;
30306 char * kwnames[] = {
30307 (char *) "self",(char *) "onlyIfNeeded", NULL
30308 };
30309
30310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30312 if (!SWIG_IsOK(res1)) {
30313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30314 }
30315 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30316 if (obj1) {
30317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30318 if (!SWIG_IsOK(ecode2)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30320 }
30321 arg2 = static_cast< bool >(val2);
30322 }
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (bool)(arg1)->Yield(arg2);
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 {
30330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30339 PyObject *resultobj = 0;
30340 wxPyApp *arg1 = (wxPyApp *) 0 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 PyObject *swig_obj[1] ;
30344
30345 if (!args) SWIG_fail;
30346 swig_obj[0] = args;
30347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30350 }
30351 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 (arg1)->WakeUpIdle();
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_Py_Void();
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30366 PyObject *resultobj = 0;
30367 bool result;
30368
30369 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (bool)wxPyApp::IsMainLoopRunning();
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 {
30377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30378 }
30379 return resultobj;
30380 fail:
30381 return NULL;
30382 }
30383
30384
30385 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30386 PyObject *resultobj = 0;
30387 wxPyApp *arg1 = (wxPyApp *) 0 ;
30388 int result;
30389 void *argp1 = 0 ;
30390 int res1 = 0 ;
30391 PyObject *swig_obj[1] ;
30392
30393 if (!args) SWIG_fail;
30394 swig_obj[0] = args;
30395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30398 }
30399 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30400 {
30401 PyThreadState* __tstate = wxPyBeginAllowThreads();
30402 result = (int)(arg1)->MainLoop();
30403 wxPyEndAllowThreads(__tstate);
30404 if (PyErr_Occurred()) SWIG_fail;
30405 }
30406 resultobj = SWIG_From_int(static_cast< int >(result));
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30414 PyObject *resultobj = 0;
30415 wxPyApp *arg1 = (wxPyApp *) 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 PyObject *swig_obj[1] ;
30419
30420 if (!args) SWIG_fail;
30421 swig_obj[0] = args;
30422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30423 if (!SWIG_IsOK(res1)) {
30424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30425 }
30426 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 (arg1)->Exit();
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_Py_Void();
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30441 PyObject *resultobj = 0;
30442 wxPyApp *arg1 = (wxPyApp *) 0 ;
30443 wxLayoutDirection result;
30444 void *argp1 = 0 ;
30445 int res1 = 0 ;
30446 PyObject *swig_obj[1] ;
30447
30448 if (!args) SWIG_fail;
30449 swig_obj[0] = args;
30450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30451 if (!SWIG_IsOK(res1)) {
30452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30453 }
30454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_From_int(static_cast< int >(result));
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30469 PyObject *resultobj = 0;
30470 wxPyApp *arg1 = (wxPyApp *) 0 ;
30471 void *argp1 = 0 ;
30472 int res1 = 0 ;
30473 PyObject *swig_obj[1] ;
30474
30475 if (!args) SWIG_fail;
30476 swig_obj[0] = args;
30477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30478 if (!SWIG_IsOK(res1)) {
30479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30480 }
30481 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 (arg1)->ExitMainLoop();
30485 wxPyEndAllowThreads(__tstate);
30486 if (PyErr_Occurred()) SWIG_fail;
30487 }
30488 resultobj = SWIG_Py_Void();
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30496 PyObject *resultobj = 0;
30497 wxPyApp *arg1 = (wxPyApp *) 0 ;
30498 bool result;
30499 void *argp1 = 0 ;
30500 int res1 = 0 ;
30501 PyObject *swig_obj[1] ;
30502
30503 if (!args) SWIG_fail;
30504 swig_obj[0] = args;
30505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30506 if (!SWIG_IsOK(res1)) {
30507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30508 }
30509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30510 {
30511 PyThreadState* __tstate = wxPyBeginAllowThreads();
30512 result = (bool)(arg1)->Pending();
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 {
30517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30518 }
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30526 PyObject *resultobj = 0;
30527 wxPyApp *arg1 = (wxPyApp *) 0 ;
30528 bool result;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 PyObject *swig_obj[1] ;
30532
30533 if (!args) SWIG_fail;
30534 swig_obj[0] = args;
30535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30536 if (!SWIG_IsOK(res1)) {
30537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30538 }
30539 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = (bool)(arg1)->Dispatch();
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 {
30547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30548 }
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxPyApp *arg1 = (wxPyApp *) 0 ;
30558 bool result;
30559 void *argp1 = 0 ;
30560 int res1 = 0 ;
30561 PyObject *swig_obj[1] ;
30562
30563 if (!args) SWIG_fail;
30564 swig_obj[0] = args;
30565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30568 }
30569 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 result = (bool)(arg1)->ProcessIdle();
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 {
30577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30586 PyObject *resultobj = 0;
30587 wxPyApp *arg1 = (wxPyApp *) 0 ;
30588 wxWindow *arg2 = (wxWindow *) 0 ;
30589 wxIdleEvent *arg3 = 0 ;
30590 bool result;
30591 void *argp1 = 0 ;
30592 int res1 = 0 ;
30593 void *argp2 = 0 ;
30594 int res2 = 0 ;
30595 void *argp3 = 0 ;
30596 int res3 = 0 ;
30597 PyObject * obj0 = 0 ;
30598 PyObject * obj1 = 0 ;
30599 PyObject * obj2 = 0 ;
30600 char * kwnames[] = {
30601 (char *) "self",(char *) "win",(char *) "event", NULL
30602 };
30603
30604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30606 if (!SWIG_IsOK(res1)) {
30607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30608 }
30609 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res2)) {
30612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30613 }
30614 arg2 = reinterpret_cast< wxWindow * >(argp2);
30615 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30616 if (!SWIG_IsOK(res3)) {
30617 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30618 }
30619 if (!argp3) {
30620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30621 }
30622 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30623 {
30624 PyThreadState* __tstate = wxPyBeginAllowThreads();
30625 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 {
30630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30631 }
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639 PyObject *resultobj = 0;
30640 wxPyApp *arg1 = (wxPyApp *) 0 ;
30641 bool result;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 PyObject *swig_obj[1] ;
30645
30646 if (!args) SWIG_fail;
30647 swig_obj[0] = args;
30648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30649 if (!SWIG_IsOK(res1)) {
30650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30651 }
30652 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = (bool)((wxPyApp const *)arg1)->IsActive();
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 {
30660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30661 }
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30669 PyObject *resultobj = 0;
30670 wxPyApp *arg1 = (wxPyApp *) 0 ;
30671 wxWindow *arg2 = (wxWindow *) 0 ;
30672 void *argp1 = 0 ;
30673 int res1 = 0 ;
30674 void *argp2 = 0 ;
30675 int res2 = 0 ;
30676 PyObject * obj0 = 0 ;
30677 PyObject * obj1 = 0 ;
30678 char * kwnames[] = {
30679 (char *) "self",(char *) "win", NULL
30680 };
30681
30682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30684 if (!SWIG_IsOK(res1)) {
30685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30686 }
30687 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30688 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30689 if (!SWIG_IsOK(res2)) {
30690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30691 }
30692 arg2 = reinterpret_cast< wxWindow * >(argp2);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 (arg1)->SetTopWindow(arg2);
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_Py_Void();
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30707 PyObject *resultobj = 0;
30708 wxPyApp *arg1 = (wxPyApp *) 0 ;
30709 wxWindow *result = 0 ;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 PyObject *swig_obj[1] ;
30713
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 resultobj = wxPyMake_wxObject(result, (bool)0);
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30737 PyObject *resultobj = 0;
30738 wxPyApp *arg1 = (wxPyApp *) 0 ;
30739 bool arg2 ;
30740 void *argp1 = 0 ;
30741 int res1 = 0 ;
30742 bool val2 ;
30743 int ecode2 = 0 ;
30744 PyObject * obj0 = 0 ;
30745 PyObject * obj1 = 0 ;
30746 char * kwnames[] = {
30747 (char *) "self",(char *) "flag", NULL
30748 };
30749
30750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30752 if (!SWIG_IsOK(res1)) {
30753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30754 }
30755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30757 if (!SWIG_IsOK(ecode2)) {
30758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30759 }
30760 arg2 = static_cast< bool >(val2);
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 (arg1)->SetExitOnFrameDelete(arg2);
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_Py_Void();
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30775 PyObject *resultobj = 0;
30776 wxPyApp *arg1 = (wxPyApp *) 0 ;
30777 bool result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 PyObject *swig_obj[1] ;
30781
30782 if (!args) SWIG_fail;
30783 swig_obj[0] = args;
30784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30787 }
30788 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 {
30796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30797 }
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj = 0;
30806 wxPyApp *arg1 = (wxPyApp *) 0 ;
30807 bool arg2 ;
30808 bool arg3 = (bool) false ;
30809 void *argp1 = 0 ;
30810 int res1 = 0 ;
30811 bool val2 ;
30812 int ecode2 = 0 ;
30813 bool val3 ;
30814 int ecode3 = 0 ;
30815 PyObject * obj0 = 0 ;
30816 PyObject * obj1 = 0 ;
30817 PyObject * obj2 = 0 ;
30818 char * kwnames[] = {
30819 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30820 };
30821
30822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30824 if (!SWIG_IsOK(res1)) {
30825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30826 }
30827 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30828 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30829 if (!SWIG_IsOK(ecode2)) {
30830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30831 }
30832 arg2 = static_cast< bool >(val2);
30833 if (obj2) {
30834 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30835 if (!SWIG_IsOK(ecode3)) {
30836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30837 }
30838 arg3 = static_cast< bool >(val3);
30839 }
30840 {
30841 PyThreadState* __tstate = wxPyBeginAllowThreads();
30842 (arg1)->SetUseBestVisual(arg2,arg3);
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 resultobj = SWIG_Py_Void();
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30854 PyObject *resultobj = 0;
30855 wxPyApp *arg1 = (wxPyApp *) 0 ;
30856 bool result;
30857 void *argp1 = 0 ;
30858 int res1 = 0 ;
30859 PyObject *swig_obj[1] ;
30860
30861 if (!args) SWIG_fail;
30862 swig_obj[0] = args;
30863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30864 if (!SWIG_IsOK(res1)) {
30865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30866 }
30867 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 {
30875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30876 }
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30884 PyObject *resultobj = 0;
30885 wxPyApp *arg1 = (wxPyApp *) 0 ;
30886 int arg2 ;
30887 void *argp1 = 0 ;
30888 int res1 = 0 ;
30889 int val2 ;
30890 int ecode2 = 0 ;
30891 PyObject * obj0 = 0 ;
30892 PyObject * obj1 = 0 ;
30893 char * kwnames[] = {
30894 (char *) "self",(char *) "mode", NULL
30895 };
30896
30897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30899 if (!SWIG_IsOK(res1)) {
30900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30901 }
30902 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30903 ecode2 = SWIG_AsVal_int(obj1, &val2);
30904 if (!SWIG_IsOK(ecode2)) {
30905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30906 }
30907 arg2 = static_cast< int >(val2);
30908 {
30909 PyThreadState* __tstate = wxPyBeginAllowThreads();
30910 (arg1)->SetPrintMode(arg2);
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 resultobj = SWIG_Py_Void();
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30922 PyObject *resultobj = 0;
30923 wxPyApp *arg1 = (wxPyApp *) 0 ;
30924 int result;
30925 void *argp1 = 0 ;
30926 int res1 = 0 ;
30927 PyObject *swig_obj[1] ;
30928
30929 if (!args) SWIG_fail;
30930 swig_obj[0] = args;
30931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30932 if (!SWIG_IsOK(res1)) {
30933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30934 }
30935 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30939 wxPyEndAllowThreads(__tstate);
30940 if (PyErr_Occurred()) SWIG_fail;
30941 }
30942 resultobj = SWIG_From_int(static_cast< int >(result));
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxPyApp *arg1 = (wxPyApp *) 0 ;
30952 int arg2 ;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 int val2 ;
30956 int ecode2 = 0 ;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 char * kwnames[] = {
30960 (char *) "self",(char *) "mode", NULL
30961 };
30962
30963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30965 if (!SWIG_IsOK(res1)) {
30966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30967 }
30968 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30969 ecode2 = SWIG_AsVal_int(obj1, &val2);
30970 if (!SWIG_IsOK(ecode2)) {
30971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30972 }
30973 arg2 = static_cast< int >(val2);
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 (arg1)->SetAssertMode(arg2);
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 resultobj = SWIG_Py_Void();
30981 return resultobj;
30982 fail:
30983 return NULL;
30984 }
30985
30986
30987 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30988 PyObject *resultobj = 0;
30989 wxPyApp *arg1 = (wxPyApp *) 0 ;
30990 int result;
30991 void *argp1 = 0 ;
30992 int res1 = 0 ;
30993 PyObject *swig_obj[1] ;
30994
30995 if (!args) SWIG_fail;
30996 swig_obj[0] = args;
30997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30998 if (!SWIG_IsOK(res1)) {
30999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31000 }
31001 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 result = (int)(arg1)->GetAssertMode();
31005 wxPyEndAllowThreads(__tstate);
31006 if (PyErr_Occurred()) SWIG_fail;
31007 }
31008 resultobj = SWIG_From_int(static_cast< int >(result));
31009 return resultobj;
31010 fail:
31011 return NULL;
31012 }
31013
31014
31015 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31016 PyObject *resultobj = 0;
31017 bool result;
31018
31019 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 {
31027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31028 }
31029 return resultobj;
31030 fail:
31031 return NULL;
31032 }
31033
31034
31035 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31036 PyObject *resultobj = 0;
31037 long result;
31038
31039 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = (long)wxPyApp::GetMacAboutMenuItemId();
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_From_long(static_cast< long >(result));
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31054 PyObject *resultobj = 0;
31055 long result;
31056
31057 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31061 wxPyEndAllowThreads(__tstate);
31062 if (PyErr_Occurred()) SWIG_fail;
31063 }
31064 resultobj = SWIG_From_long(static_cast< long >(result));
31065 return resultobj;
31066 fail:
31067 return NULL;
31068 }
31069
31070
31071 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31072 PyObject *resultobj = 0;
31073 long result;
31074
31075 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31076 {
31077 PyThreadState* __tstate = wxPyBeginAllowThreads();
31078 result = (long)wxPyApp::GetMacExitMenuItemId();
31079 wxPyEndAllowThreads(__tstate);
31080 if (PyErr_Occurred()) SWIG_fail;
31081 }
31082 resultobj = SWIG_From_long(static_cast< long >(result));
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31090 PyObject *resultobj = 0;
31091 wxString result;
31092
31093 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 result = wxPyApp::GetMacHelpMenuTitleName();
31097 wxPyEndAllowThreads(__tstate);
31098 if (PyErr_Occurred()) SWIG_fail;
31099 }
31100 {
31101 #if wxUSE_UNICODE
31102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31103 #else
31104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31105 #endif
31106 }
31107 return resultobj;
31108 fail:
31109 return NULL;
31110 }
31111
31112
31113 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31114 PyObject *resultobj = 0;
31115 bool arg1 ;
31116 bool val1 ;
31117 int ecode1 = 0 ;
31118 PyObject * obj0 = 0 ;
31119 char * kwnames[] = {
31120 (char *) "val", NULL
31121 };
31122
31123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31124 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31125 if (!SWIG_IsOK(ecode1)) {
31126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31127 }
31128 arg1 = static_cast< bool >(val1);
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 resultobj = SWIG_Py_Void();
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj = 0;
31144 long arg1 ;
31145 long val1 ;
31146 int ecode1 = 0 ;
31147 PyObject * obj0 = 0 ;
31148 char * kwnames[] = {
31149 (char *) "val", NULL
31150 };
31151
31152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31153 ecode1 = SWIG_AsVal_long(obj0, &val1);
31154 if (!SWIG_IsOK(ecode1)) {
31155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31156 }
31157 arg1 = static_cast< long >(val1);
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 wxPyApp::SetMacAboutMenuItemId(arg1);
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 resultobj = SWIG_Py_Void();
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31172 PyObject *resultobj = 0;
31173 long arg1 ;
31174 long val1 ;
31175 int ecode1 = 0 ;
31176 PyObject * obj0 = 0 ;
31177 char * kwnames[] = {
31178 (char *) "val", NULL
31179 };
31180
31181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31182 ecode1 = SWIG_AsVal_long(obj0, &val1);
31183 if (!SWIG_IsOK(ecode1)) {
31184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31185 }
31186 arg1 = static_cast< long >(val1);
31187 {
31188 PyThreadState* __tstate = wxPyBeginAllowThreads();
31189 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 resultobj = SWIG_Py_Void();
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31201 PyObject *resultobj = 0;
31202 long arg1 ;
31203 long val1 ;
31204 int ecode1 = 0 ;
31205 PyObject * obj0 = 0 ;
31206 char * kwnames[] = {
31207 (char *) "val", NULL
31208 };
31209
31210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31211 ecode1 = SWIG_AsVal_long(obj0, &val1);
31212 if (!SWIG_IsOK(ecode1)) {
31213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31214 }
31215 arg1 = static_cast< long >(val1);
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 wxPyApp::SetMacExitMenuItemId(arg1);
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_Py_Void();
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj = 0;
31231 wxString *arg1 = 0 ;
31232 bool temp1 = false ;
31233 PyObject * obj0 = 0 ;
31234 char * kwnames[] = {
31235 (char *) "val", NULL
31236 };
31237
31238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31239 {
31240 arg1 = wxString_in_helper(obj0);
31241 if (arg1 == NULL) SWIG_fail;
31242 temp1 = true;
31243 }
31244 {
31245 PyThreadState* __tstate = wxPyBeginAllowThreads();
31246 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31247 wxPyEndAllowThreads(__tstate);
31248 if (PyErr_Occurred()) SWIG_fail;
31249 }
31250 resultobj = SWIG_Py_Void();
31251 {
31252 if (temp1)
31253 delete arg1;
31254 }
31255 return resultobj;
31256 fail:
31257 {
31258 if (temp1)
31259 delete arg1;
31260 }
31261 return NULL;
31262 }
31263
31264
31265 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31266 PyObject *resultobj = 0;
31267 wxPyApp *arg1 = (wxPyApp *) 0 ;
31268 void *argp1 = 0 ;
31269 int res1 = 0 ;
31270 PyObject *swig_obj[1] ;
31271
31272 if (!args) SWIG_fail;
31273 swig_obj[0] = args;
31274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31275 if (!SWIG_IsOK(res1)) {
31276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31277 }
31278 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 (arg1)->_BootstrapApp();
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_Py_Void();
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31293 PyObject *resultobj = 0;
31294 int result;
31295
31296 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = (int)wxPyApp_GetComCtl32Version();
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_From_int(static_cast< int >(result));
31304 return resultobj;
31305 fail:
31306 return NULL;
31307 }
31308
31309
31310 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31311 PyObject *resultobj = 0;
31312 bool result;
31313
31314 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 result = (bool)wxPyApp_IsDisplayAvailable();
31318 wxPyEndAllowThreads(__tstate);
31319 if (PyErr_Occurred()) SWIG_fail;
31320 }
31321 {
31322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31323 }
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31331 PyObject *obj;
31332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31333 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31334 return SWIG_Py_Void();
31335 }
31336
31337 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31338 return SWIG_Python_InitShadowInstance(args);
31339 }
31340
31341 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31342 PyObject *resultobj = 0;
31343
31344 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 wxExit();
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_Py_Void();
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31359 PyObject *resultobj = 0;
31360 bool result;
31361
31362 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = (bool)wxYield();
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 {
31370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31371 }
31372 return resultobj;
31373 fail:
31374 return NULL;
31375 }
31376
31377
31378 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31379 PyObject *resultobj = 0;
31380 bool result;
31381
31382 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 result = (bool)wxYieldIfNeeded();
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 {
31390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31391 }
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj = 0;
31400 wxWindow *arg1 = (wxWindow *) NULL ;
31401 bool arg2 = (bool) false ;
31402 bool result;
31403 void *argp1 = 0 ;
31404 int res1 = 0 ;
31405 bool val2 ;
31406 int ecode2 = 0 ;
31407 PyObject * obj0 = 0 ;
31408 PyObject * obj1 = 0 ;
31409 char * kwnames[] = {
31410 (char *) "win",(char *) "onlyIfNeeded", NULL
31411 };
31412
31413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31414 if (obj0) {
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 '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31418 }
31419 arg1 = reinterpret_cast< wxWindow * >(argp1);
31420 }
31421 if (obj1) {
31422 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31423 if (!SWIG_IsOK(ecode2)) {
31424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31425 }
31426 arg2 = static_cast< bool >(val2);
31427 }
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 result = (bool)wxSafeYield(arg1,arg2);
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 {
31435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31436 }
31437 return resultobj;
31438 fail:
31439 return NULL;
31440 }
31441
31442
31443 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31444 PyObject *resultobj = 0;
31445
31446 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 wxWakeUpIdle();
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 resultobj = SWIG_Py_Void();
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31461 PyObject *resultobj = 0;
31462 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31463 wxEvent *arg2 = 0 ;
31464 void *argp1 = 0 ;
31465 int res1 = 0 ;
31466 void *argp2 = 0 ;
31467 int res2 = 0 ;
31468 PyObject * obj0 = 0 ;
31469 PyObject * obj1 = 0 ;
31470 char * kwnames[] = {
31471 (char *) "dest",(char *) "event", NULL
31472 };
31473
31474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31476 if (!SWIG_IsOK(res1)) {
31477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31478 }
31479 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31480 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31481 if (!SWIG_IsOK(res2)) {
31482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31483 }
31484 if (!argp2) {
31485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31486 }
31487 arg2 = reinterpret_cast< wxEvent * >(argp2);
31488 {
31489 PyThreadState* __tstate = wxPyBeginAllowThreads();
31490 wxPostEvent(arg1,*arg2);
31491 wxPyEndAllowThreads(__tstate);
31492 if (PyErr_Occurred()) SWIG_fail;
31493 }
31494 resultobj = SWIG_Py_Void();
31495 return resultobj;
31496 fail:
31497 return NULL;
31498 }
31499
31500
31501 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31502 PyObject *resultobj = 0;
31503
31504 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31505 {
31506 PyThreadState* __tstate = wxPyBeginAllowThreads();
31507 wxApp_CleanUp();
31508 wxPyEndAllowThreads(__tstate);
31509 if (PyErr_Occurred()) SWIG_fail;
31510 }
31511 resultobj = SWIG_Py_Void();
31512 return resultobj;
31513 fail:
31514 return NULL;
31515 }
31516
31517
31518 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31519 PyObject *resultobj = 0;
31520 wxPyApp *result = 0 ;
31521
31522 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 result = (wxPyApp *)wxPyGetApp();
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 {
31530 resultobj = wxPyMake_wxObject(result, 0);
31531 }
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31539 PyObject *resultobj = 0;
31540 char *arg1 = (char *) 0 ;
31541 int res1 ;
31542 char *buf1 = 0 ;
31543 int alloc1 = 0 ;
31544 PyObject * obj0 = 0 ;
31545 char * kwnames[] = {
31546 (char *) "encoding", NULL
31547 };
31548
31549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31550 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31551 if (!SWIG_IsOK(res1)) {
31552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31553 }
31554 arg1 = buf1;
31555 {
31556 PyThreadState* __tstate = wxPyBeginAllowThreads();
31557 wxSetDefaultPyEncoding((char const *)arg1);
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 resultobj = SWIG_Py_Void();
31562 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31563 return resultobj;
31564 fail:
31565 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31566 return NULL;
31567 }
31568
31569
31570 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31571 PyObject *resultobj = 0;
31572 char *result = 0 ;
31573
31574 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 result = (char *)wxGetDefaultPyEncoding();
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 resultobj = SWIG_FromCharPtr(result);
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31589 PyObject *resultobj = 0;
31590 wxEventLoop *result = 0 ;
31591
31592 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 result = (wxEventLoop *)new wxEventLoop();
31596 wxPyEndAllowThreads(__tstate);
31597 if (PyErr_Occurred()) SWIG_fail;
31598 }
31599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31600 return resultobj;
31601 fail:
31602 return NULL;
31603 }
31604
31605
31606 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31607 PyObject *resultobj = 0;
31608 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31609 void *argp1 = 0 ;
31610 int res1 = 0 ;
31611 PyObject *swig_obj[1] ;
31612
31613 if (!args) SWIG_fail;
31614 swig_obj[0] = args;
31615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31616 if (!SWIG_IsOK(res1)) {
31617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31618 }
31619 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31620 {
31621 PyThreadState* __tstate = wxPyBeginAllowThreads();
31622 delete arg1;
31623
31624 wxPyEndAllowThreads(__tstate);
31625 if (PyErr_Occurred()) SWIG_fail;
31626 }
31627 resultobj = SWIG_Py_Void();
31628 return resultobj;
31629 fail:
31630 return NULL;
31631 }
31632
31633
31634 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31635 PyObject *resultobj = 0;
31636 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31637 int result;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 PyObject *swig_obj[1] ;
31641
31642 if (!args) SWIG_fail;
31643 swig_obj[0] = args;
31644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31645 if (!SWIG_IsOK(res1)) {
31646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31647 }
31648 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31649 {
31650 PyThreadState* __tstate = wxPyBeginAllowThreads();
31651 result = (int)(arg1)->Run();
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 resultobj = SWIG_From_int(static_cast< int >(result));
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31663 PyObject *resultobj = 0;
31664 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31665 int arg2 = (int) 0 ;
31666 void *argp1 = 0 ;
31667 int res1 = 0 ;
31668 int val2 ;
31669 int ecode2 = 0 ;
31670 PyObject * obj0 = 0 ;
31671 PyObject * obj1 = 0 ;
31672 char * kwnames[] = {
31673 (char *) "self",(char *) "rc", NULL
31674 };
31675
31676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31678 if (!SWIG_IsOK(res1)) {
31679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31680 }
31681 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31682 if (obj1) {
31683 ecode2 = SWIG_AsVal_int(obj1, &val2);
31684 if (!SWIG_IsOK(ecode2)) {
31685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31686 }
31687 arg2 = static_cast< int >(val2);
31688 }
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 (arg1)->Exit(arg2);
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 resultobj = SWIG_Py_Void();
31696 return resultobj;
31697 fail:
31698 return NULL;
31699 }
31700
31701
31702 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31703 PyObject *resultobj = 0;
31704 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31705 bool result;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 PyObject *swig_obj[1] ;
31709
31710 if (!args) SWIG_fail;
31711 swig_obj[0] = args;
31712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31713 if (!SWIG_IsOK(res1)) {
31714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31715 }
31716 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31717 {
31718 PyThreadState* __tstate = wxPyBeginAllowThreads();
31719 result = (bool)((wxEventLoop const *)arg1)->Pending();
31720 wxPyEndAllowThreads(__tstate);
31721 if (PyErr_Occurred()) SWIG_fail;
31722 }
31723 {
31724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31725 }
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31735 bool 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_wxEventLoop, 0 | 0 );
31743 if (!SWIG_IsOK(res1)) {
31744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31745 }
31746 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = (bool)(arg1)->Dispatch();
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 {
31754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31755 }
31756 return resultobj;
31757 fail:
31758 return NULL;
31759 }
31760
31761
31762 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31763 PyObject *resultobj = 0;
31764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31765 bool result;
31766 void *argp1 = 0 ;
31767 int res1 = 0 ;
31768 PyObject *swig_obj[1] ;
31769
31770 if (!args) SWIG_fail;
31771 swig_obj[0] = args;
31772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31773 if (!SWIG_IsOK(res1)) {
31774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31775 }
31776 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 {
31784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31785 }
31786 return resultobj;
31787 fail:
31788 return NULL;
31789 }
31790
31791
31792 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31793 PyObject *resultobj = 0;
31794 wxEventLoop *result = 0 ;
31795
31796 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31797 {
31798 PyThreadState* __tstate = wxPyBeginAllowThreads();
31799 result = (wxEventLoop *)wxEventLoop::GetActive();
31800 wxPyEndAllowThreads(__tstate);
31801 if (PyErr_Occurred()) SWIG_fail;
31802 }
31803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31804 return resultobj;
31805 fail:
31806 return NULL;
31807 }
31808
31809
31810 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31811 PyObject *resultobj = 0;
31812 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31813 void *argp1 = 0 ;
31814 int res1 = 0 ;
31815 PyObject * obj0 = 0 ;
31816 char * kwnames[] = {
31817 (char *) "loop", NULL
31818 };
31819
31820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31822 if (!SWIG_IsOK(res1)) {
31823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31824 }
31825 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31826 {
31827 PyThreadState* __tstate = wxPyBeginAllowThreads();
31828 wxEventLoop::SetActive(arg1);
31829 wxPyEndAllowThreads(__tstate);
31830 if (PyErr_Occurred()) SWIG_fail;
31831 }
31832 resultobj = SWIG_Py_Void();
31833 return resultobj;
31834 fail:
31835 return NULL;
31836 }
31837
31838
31839 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31840 PyObject *obj;
31841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31842 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31843 return SWIG_Py_Void();
31844 }
31845
31846 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31847 return SWIG_Python_InitShadowInstance(args);
31848 }
31849
31850 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31851 PyObject *resultobj = 0;
31852 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31853 wxEventLoopActivator *result = 0 ;
31854 void *argp1 = 0 ;
31855 int res1 = 0 ;
31856 PyObject * obj0 = 0 ;
31857 char * kwnames[] = {
31858 (char *) "evtLoop", NULL
31859 };
31860
31861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31865 }
31866 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 PyObject *resultobj = 0;
31882 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 PyObject *swig_obj[1] ;
31886
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31892 }
31893 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 delete arg1;
31897
31898 wxPyEndAllowThreads(__tstate);
31899 if (PyErr_Occurred()) SWIG_fail;
31900 }
31901 resultobj = SWIG_Py_Void();
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31909 PyObject *obj;
31910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31911 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31912 return SWIG_Py_Void();
31913 }
31914
31915 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31916 return SWIG_Python_InitShadowInstance(args);
31917 }
31918
31919 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31920 PyObject *resultobj = 0;
31921 int arg1 = (int) 0 ;
31922 int arg2 = (int) 0 ;
31923 int arg3 = (int) 0 ;
31924 wxAcceleratorEntry *result = 0 ;
31925 int val1 ;
31926 int ecode1 = 0 ;
31927 int val2 ;
31928 int ecode2 = 0 ;
31929 int val3 ;
31930 int ecode3 = 0 ;
31931 PyObject * obj0 = 0 ;
31932 PyObject * obj1 = 0 ;
31933 PyObject * obj2 = 0 ;
31934 char * kwnames[] = {
31935 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31936 };
31937
31938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31939 if (obj0) {
31940 ecode1 = SWIG_AsVal_int(obj0, &val1);
31941 if (!SWIG_IsOK(ecode1)) {
31942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31943 }
31944 arg1 = static_cast< int >(val1);
31945 }
31946 if (obj1) {
31947 ecode2 = SWIG_AsVal_int(obj1, &val2);
31948 if (!SWIG_IsOK(ecode2)) {
31949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31950 }
31951 arg2 = static_cast< int >(val2);
31952 }
31953 if (obj2) {
31954 ecode3 = SWIG_AsVal_int(obj2, &val3);
31955 if (!SWIG_IsOK(ecode3)) {
31956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31957 }
31958 arg3 = static_cast< int >(val3);
31959 }
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 PyObject *resultobj = 0;
31975 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31976 void *argp1 = 0 ;
31977 int res1 = 0 ;
31978 PyObject *swig_obj[1] ;
31979
31980 if (!args) SWIG_fail;
31981 swig_obj[0] = args;
31982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31983 if (!SWIG_IsOK(res1)) {
31984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31985 }
31986 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31987 {
31988 PyThreadState* __tstate = wxPyBeginAllowThreads();
31989 delete arg1;
31990
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 resultobj = SWIG_Py_Void();
31995 return resultobj;
31996 fail:
31997 return NULL;
31998 }
31999
32000
32001 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32002 PyObject *resultobj = 0;
32003 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32004 int arg2 ;
32005 int arg3 ;
32006 int arg4 ;
32007 void *argp1 = 0 ;
32008 int res1 = 0 ;
32009 int val2 ;
32010 int ecode2 = 0 ;
32011 int val3 ;
32012 int ecode3 = 0 ;
32013 int val4 ;
32014 int ecode4 = 0 ;
32015 PyObject * obj0 = 0 ;
32016 PyObject * obj1 = 0 ;
32017 PyObject * obj2 = 0 ;
32018 PyObject * obj3 = 0 ;
32019 char * kwnames[] = {
32020 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32021 };
32022
32023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32025 if (!SWIG_IsOK(res1)) {
32026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32027 }
32028 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32029 ecode2 = SWIG_AsVal_int(obj1, &val2);
32030 if (!SWIG_IsOK(ecode2)) {
32031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32032 }
32033 arg2 = static_cast< int >(val2);
32034 ecode3 = SWIG_AsVal_int(obj2, &val3);
32035 if (!SWIG_IsOK(ecode3)) {
32036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32037 }
32038 arg3 = static_cast< int >(val3);
32039 ecode4 = SWIG_AsVal_int(obj3, &val4);
32040 if (!SWIG_IsOK(ecode4)) {
32041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32042 }
32043 arg4 = static_cast< int >(val4);
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 (arg1)->Set(arg2,arg3,arg4);
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_Py_Void();
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32058 PyObject *resultobj = 0;
32059 wxString *arg1 = 0 ;
32060 wxAcceleratorEntry *result = 0 ;
32061 bool temp1 = false ;
32062 PyObject * obj0 = 0 ;
32063 char * kwnames[] = {
32064 (char *) "str", NULL
32065 };
32066
32067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32068 {
32069 arg1 = wxString_in_helper(obj0);
32070 if (arg1 == NULL) SWIG_fail;
32071 temp1 = true;
32072 }
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32076 wxPyEndAllowThreads(__tstate);
32077 if (PyErr_Occurred()) SWIG_fail;
32078 }
32079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32080 {
32081 if (temp1)
32082 delete arg1;
32083 }
32084 return resultobj;
32085 fail:
32086 {
32087 if (temp1)
32088 delete arg1;
32089 }
32090 return NULL;
32091 }
32092
32093
32094 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32095 PyObject *resultobj = 0;
32096 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32097 int result;
32098 void *argp1 = 0 ;
32099 int res1 = 0 ;
32100 PyObject *swig_obj[1] ;
32101
32102 if (!args) SWIG_fail;
32103 swig_obj[0] = args;
32104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32105 if (!SWIG_IsOK(res1)) {
32106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32107 }
32108 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32109 {
32110 PyThreadState* __tstate = wxPyBeginAllowThreads();
32111 result = (int)(arg1)->GetFlags();
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_From_int(static_cast< int >(result));
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32123 PyObject *resultobj = 0;
32124 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32125 int result;
32126 void *argp1 = 0 ;
32127 int res1 = 0 ;
32128 PyObject *swig_obj[1] ;
32129
32130 if (!args) SWIG_fail;
32131 swig_obj[0] = args;
32132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32133 if (!SWIG_IsOK(res1)) {
32134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32135 }
32136 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (int)(arg1)->GetKeyCode();
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 resultobj = SWIG_From_int(static_cast< int >(result));
32144 return resultobj;
32145 fail:
32146 return NULL;
32147 }
32148
32149
32150 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32151 PyObject *resultobj = 0;
32152 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32153 int result;
32154 void *argp1 = 0 ;
32155 int res1 = 0 ;
32156 PyObject *swig_obj[1] ;
32157
32158 if (!args) SWIG_fail;
32159 swig_obj[0] = args;
32160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32161 if (!SWIG_IsOK(res1)) {
32162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32163 }
32164 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32165 {
32166 PyThreadState* __tstate = wxPyBeginAllowThreads();
32167 result = (int)(arg1)->GetCommand();
32168 wxPyEndAllowThreads(__tstate);
32169 if (PyErr_Occurred()) SWIG_fail;
32170 }
32171 resultobj = SWIG_From_int(static_cast< int >(result));
32172 return resultobj;
32173 fail:
32174 return NULL;
32175 }
32176
32177
32178 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32179 PyObject *resultobj = 0;
32180 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32181 bool result;
32182 void *argp1 = 0 ;
32183 int res1 = 0 ;
32184 PyObject *swig_obj[1] ;
32185
32186 if (!args) SWIG_fail;
32187 swig_obj[0] = args;
32188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32189 if (!SWIG_IsOK(res1)) {
32190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32191 }
32192 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 {
32200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32201 }
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32211 wxString result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject *swig_obj[1] ;
32215
32216 if (!args) SWIG_fail;
32217 swig_obj[0] = args;
32218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32219 if (!SWIG_IsOK(res1)) {
32220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32221 }
32222 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 {
32230 #if wxUSE_UNICODE
32231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32232 #else
32233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32234 #endif
32235 }
32236 return resultobj;
32237 fail:
32238 return NULL;
32239 }
32240
32241
32242 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32243 PyObject *resultobj = 0;
32244 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32245 wxString *arg2 = 0 ;
32246 bool result;
32247 void *argp1 = 0 ;
32248 int res1 = 0 ;
32249 bool temp2 = false ;
32250 PyObject * obj0 = 0 ;
32251 PyObject * obj1 = 0 ;
32252 char * kwnames[] = {
32253 (char *) "self",(char *) "str", NULL
32254 };
32255
32256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32258 if (!SWIG_IsOK(res1)) {
32259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32260 }
32261 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32262 {
32263 arg2 = wxString_in_helper(obj1);
32264 if (arg2 == NULL) SWIG_fail;
32265 temp2 = true;
32266 }
32267 {
32268 PyThreadState* __tstate = wxPyBeginAllowThreads();
32269 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32270 wxPyEndAllowThreads(__tstate);
32271 if (PyErr_Occurred()) SWIG_fail;
32272 }
32273 {
32274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32275 }
32276 {
32277 if (temp2)
32278 delete arg2;
32279 }
32280 return resultobj;
32281 fail:
32282 {
32283 if (temp2)
32284 delete arg2;
32285 }
32286 return NULL;
32287 }
32288
32289
32290 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32291 PyObject *obj;
32292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32293 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32294 return SWIG_Py_Void();
32295 }
32296
32297 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32298 return SWIG_Python_InitShadowInstance(args);
32299 }
32300
32301 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32302 PyObject *resultobj = 0;
32303 int arg1 ;
32304 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32305 wxAcceleratorTable *result = 0 ;
32306 PyObject * obj0 = 0 ;
32307 char * kwnames[] = {
32308 (char *) "n", NULL
32309 };
32310
32311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32312 {
32313 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32314 if (arg2) arg1 = PyList_Size(obj0);
32315 else arg1 = 0;
32316 }
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 PyObject *swig_obj[1] ;
32336
32337 if (!args) SWIG_fail;
32338 swig_obj[0] = args;
32339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32340 if (!SWIG_IsOK(res1)) {
32341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32342 }
32343 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 delete arg1;
32347
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = SWIG_Py_Void();
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32359 PyObject *resultobj = 0;
32360 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32361 bool result;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 PyObject *swig_obj[1] ;
32365
32366 if (!args) SWIG_fail;
32367 swig_obj[0] = args;
32368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32369 if (!SWIG_IsOK(res1)) {
32370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32371 }
32372 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32376 wxPyEndAllowThreads(__tstate);
32377 if (PyErr_Occurred()) SWIG_fail;
32378 }
32379 {
32380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32381 }
32382 return resultobj;
32383 fail:
32384 return NULL;
32385 }
32386
32387
32388 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32389 PyObject *obj;
32390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32391 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32392 return SWIG_Py_Void();
32393 }
32394
32395 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 return SWIG_Python_InitShadowInstance(args);
32397 }
32398
32399 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32400 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32401 return 1;
32402 }
32403
32404
32405 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32406 PyObject *pyobj = 0;
32407
32408 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32409 return pyobj;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxString *arg1 = 0 ;
32416 wxAcceleratorEntry *result = 0 ;
32417 bool temp1 = false ;
32418 PyObject * obj0 = 0 ;
32419 char * kwnames[] = {
32420 (char *) "label", NULL
32421 };
32422
32423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32424 {
32425 arg1 = wxString_in_helper(obj0);
32426 if (arg1 == NULL) SWIG_fail;
32427 temp1 = true;
32428 }
32429 {
32430 PyThreadState* __tstate = wxPyBeginAllowThreads();
32431 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32432 wxPyEndAllowThreads(__tstate);
32433 if (PyErr_Occurred()) SWIG_fail;
32434 }
32435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32436 {
32437 if (temp1)
32438 delete arg1;
32439 }
32440 return resultobj;
32441 fail:
32442 {
32443 if (temp1)
32444 delete arg1;
32445 }
32446 return NULL;
32447 }
32448
32449
32450 SWIGINTERN int PanelNameStr_set(PyObject *) {
32451 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32452 return 1;
32453 }
32454
32455
32456 SWIGINTERN PyObject *PanelNameStr_get(void) {
32457 PyObject *pyobj = 0;
32458
32459 {
32460 #if wxUSE_UNICODE
32461 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32462 #else
32463 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32464 #endif
32465 }
32466 return pyobj;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32471 PyObject *resultobj = 0;
32472 wxVisualAttributes *result = 0 ;
32473
32474 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 result = (wxVisualAttributes *)new_wxVisualAttributes();
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32482 return resultobj;
32483 fail:
32484 return NULL;
32485 }
32486
32487
32488 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32489 PyObject *resultobj = 0;
32490 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32491 void *argp1 = 0 ;
32492 int res1 = 0 ;
32493 PyObject *swig_obj[1] ;
32494
32495 if (!args) SWIG_fail;
32496 swig_obj[0] = args;
32497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32498 if (!SWIG_IsOK(res1)) {
32499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32500 }
32501 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 delete_wxVisualAttributes(arg1);
32505
32506 wxPyEndAllowThreads(__tstate);
32507 if (PyErr_Occurred()) SWIG_fail;
32508 }
32509 resultobj = SWIG_Py_Void();
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32519 wxFont *arg2 = (wxFont *) 0 ;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 void *argp2 = 0 ;
32523 int res2 = 0 ;
32524 PyObject *swig_obj[2] ;
32525
32526 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32528 if (!SWIG_IsOK(res1)) {
32529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32530 }
32531 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32532 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32533 if (!SWIG_IsOK(res2)) {
32534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32535 }
32536 arg2 = reinterpret_cast< wxFont * >(argp2);
32537 if (arg1) (arg1)->font = *arg2;
32538
32539 resultobj = SWIG_Py_Void();
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32549 wxFont *result = 0 ;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32559 }
32560 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32561 result = (wxFont *)& ((arg1)->font);
32562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32563 return resultobj;
32564 fail:
32565 return NULL;
32566 }
32567
32568
32569 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32570 PyObject *resultobj = 0;
32571 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32572 wxColour *arg2 = (wxColour *) 0 ;
32573 void *argp1 = 0 ;
32574 int res1 = 0 ;
32575 void *argp2 = 0 ;
32576 int res2 = 0 ;
32577 PyObject *swig_obj[2] ;
32578
32579 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32583 }
32584 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32586 if (!SWIG_IsOK(res2)) {
32587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32588 }
32589 arg2 = reinterpret_cast< wxColour * >(argp2);
32590 if (arg1) (arg1)->colFg = *arg2;
32591
32592 resultobj = SWIG_Py_Void();
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32600 PyObject *resultobj = 0;
32601 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32602 wxColour *result = 0 ;
32603 void *argp1 = 0 ;
32604 int res1 = 0 ;
32605 PyObject *swig_obj[1] ;
32606
32607 if (!args) SWIG_fail;
32608 swig_obj[0] = args;
32609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32612 }
32613 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32614 result = (wxColour *)& ((arg1)->colFg);
32615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32623 PyObject *resultobj = 0;
32624 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32625 wxColour *arg2 = (wxColour *) 0 ;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 void *argp2 = 0 ;
32629 int res2 = 0 ;
32630 PyObject *swig_obj[2] ;
32631
32632 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32636 }
32637 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32638 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32639 if (!SWIG_IsOK(res2)) {
32640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32641 }
32642 arg2 = reinterpret_cast< wxColour * >(argp2);
32643 if (arg1) (arg1)->colBg = *arg2;
32644
32645 resultobj = SWIG_Py_Void();
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32655 wxColour *result = 0 ;
32656 void *argp1 = 0 ;
32657 int res1 = 0 ;
32658 PyObject *swig_obj[1] ;
32659
32660 if (!args) SWIG_fail;
32661 swig_obj[0] = args;
32662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32665 }
32666 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32667 result = (wxColour *)& ((arg1)->colBg);
32668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32669 return resultobj;
32670 fail:
32671 return NULL;
32672 }
32673
32674
32675 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32676 PyObject *obj;
32677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32678 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32679 return SWIG_Py_Void();
32680 }
32681
32682 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32683 return SWIG_Python_InitShadowInstance(args);
32684 }
32685
32686 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32687 PyObject *resultobj = 0;
32688 wxWindow *arg1 = (wxWindow *) 0 ;
32689 int arg2 = (int) (int)-1 ;
32690 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32691 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32692 wxSize const &arg4_defvalue = wxDefaultSize ;
32693 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32694 long arg5 = (long) 0 ;
32695 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32696 wxString *arg6 = (wxString *) &arg6_defvalue ;
32697 wxWindow *result = 0 ;
32698 void *argp1 = 0 ;
32699 int res1 = 0 ;
32700 int val2 ;
32701 int ecode2 = 0 ;
32702 wxPoint temp3 ;
32703 wxSize temp4 ;
32704 long val5 ;
32705 int ecode5 = 0 ;
32706 bool temp6 = false ;
32707 PyObject * obj0 = 0 ;
32708 PyObject * obj1 = 0 ;
32709 PyObject * obj2 = 0 ;
32710 PyObject * obj3 = 0 ;
32711 PyObject * obj4 = 0 ;
32712 PyObject * obj5 = 0 ;
32713 char * kwnames[] = {
32714 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32715 };
32716
32717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32719 if (!SWIG_IsOK(res1)) {
32720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32721 }
32722 arg1 = reinterpret_cast< wxWindow * >(argp1);
32723 if (obj1) {
32724 ecode2 = SWIG_AsVal_int(obj1, &val2);
32725 if (!SWIG_IsOK(ecode2)) {
32726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32727 }
32728 arg2 = static_cast< int >(val2);
32729 }
32730 if (obj2) {
32731 {
32732 arg3 = &temp3;
32733 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32734 }
32735 }
32736 if (obj3) {
32737 {
32738 arg4 = &temp4;
32739 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32740 }
32741 }
32742 if (obj4) {
32743 ecode5 = SWIG_AsVal_long(obj4, &val5);
32744 if (!SWIG_IsOK(ecode5)) {
32745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32746 }
32747 arg5 = static_cast< long >(val5);
32748 }
32749 if (obj5) {
32750 {
32751 arg6 = wxString_in_helper(obj5);
32752 if (arg6 == NULL) SWIG_fail;
32753 temp6 = true;
32754 }
32755 }
32756 {
32757 if (!wxPyCheckForApp()) SWIG_fail;
32758 PyThreadState* __tstate = wxPyBeginAllowThreads();
32759 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32764 {
32765 if (temp6)
32766 delete arg6;
32767 }
32768 return resultobj;
32769 fail:
32770 {
32771 if (temp6)
32772 delete arg6;
32773 }
32774 return NULL;
32775 }
32776
32777
32778 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32779 PyObject *resultobj = 0;
32780 wxWindow *result = 0 ;
32781
32782 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32783 {
32784 if (!wxPyCheckForApp()) SWIG_fail;
32785 PyThreadState* __tstate = wxPyBeginAllowThreads();
32786 result = (wxWindow *)new wxWindow();
32787 wxPyEndAllowThreads(__tstate);
32788 if (PyErr_Occurred()) SWIG_fail;
32789 }
32790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32791 return resultobj;
32792 fail:
32793 return NULL;
32794 }
32795
32796
32797 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32798 PyObject *resultobj = 0;
32799 wxWindow *arg1 = (wxWindow *) 0 ;
32800 wxWindow *arg2 = (wxWindow *) 0 ;
32801 int arg3 = (int) (int)-1 ;
32802 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32803 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32804 wxSize const &arg5_defvalue = wxDefaultSize ;
32805 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32806 long arg6 = (long) 0 ;
32807 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32808 wxString *arg7 = (wxString *) &arg7_defvalue ;
32809 bool result;
32810 void *argp1 = 0 ;
32811 int res1 = 0 ;
32812 void *argp2 = 0 ;
32813 int res2 = 0 ;
32814 int val3 ;
32815 int ecode3 = 0 ;
32816 wxPoint temp4 ;
32817 wxSize temp5 ;
32818 long val6 ;
32819 int ecode6 = 0 ;
32820 bool temp7 = false ;
32821 PyObject * obj0 = 0 ;
32822 PyObject * obj1 = 0 ;
32823 PyObject * obj2 = 0 ;
32824 PyObject * obj3 = 0 ;
32825 PyObject * obj4 = 0 ;
32826 PyObject * obj5 = 0 ;
32827 PyObject * obj6 = 0 ;
32828 char * kwnames[] = {
32829 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32830 };
32831
32832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32834 if (!SWIG_IsOK(res1)) {
32835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32836 }
32837 arg1 = reinterpret_cast< wxWindow * >(argp1);
32838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32839 if (!SWIG_IsOK(res2)) {
32840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32841 }
32842 arg2 = reinterpret_cast< wxWindow * >(argp2);
32843 if (obj2) {
32844 ecode3 = SWIG_AsVal_int(obj2, &val3);
32845 if (!SWIG_IsOK(ecode3)) {
32846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32847 }
32848 arg3 = static_cast< int >(val3);
32849 }
32850 if (obj3) {
32851 {
32852 arg4 = &temp4;
32853 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32854 }
32855 }
32856 if (obj4) {
32857 {
32858 arg5 = &temp5;
32859 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32860 }
32861 }
32862 if (obj5) {
32863 ecode6 = SWIG_AsVal_long(obj5, &val6);
32864 if (!SWIG_IsOK(ecode6)) {
32865 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32866 }
32867 arg6 = static_cast< long >(val6);
32868 }
32869 if (obj6) {
32870 {
32871 arg7 = wxString_in_helper(obj6);
32872 if (arg7 == NULL) SWIG_fail;
32873 temp7 = true;
32874 }
32875 }
32876 {
32877 PyThreadState* __tstate = wxPyBeginAllowThreads();
32878 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32879 wxPyEndAllowThreads(__tstate);
32880 if (PyErr_Occurred()) SWIG_fail;
32881 }
32882 {
32883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32884 }
32885 {
32886 if (temp7)
32887 delete arg7;
32888 }
32889 return resultobj;
32890 fail:
32891 {
32892 if (temp7)
32893 delete arg7;
32894 }
32895 return NULL;
32896 }
32897
32898
32899 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32900 PyObject *resultobj = 0;
32901 wxWindow *arg1 = (wxWindow *) 0 ;
32902 bool arg2 = (bool) false ;
32903 bool result;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 bool val2 ;
32907 int ecode2 = 0 ;
32908 PyObject * obj0 = 0 ;
32909 PyObject * obj1 = 0 ;
32910 char * kwnames[] = {
32911 (char *) "self",(char *) "force", NULL
32912 };
32913
32914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32916 if (!SWIG_IsOK(res1)) {
32917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32918 }
32919 arg1 = reinterpret_cast< wxWindow * >(argp1);
32920 if (obj1) {
32921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32922 if (!SWIG_IsOK(ecode2)) {
32923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32924 }
32925 arg2 = static_cast< bool >(val2);
32926 }
32927 {
32928 PyThreadState* __tstate = wxPyBeginAllowThreads();
32929 result = (bool)(arg1)->Close(arg2);
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 {
32934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32935 }
32936 return resultobj;
32937 fail:
32938 return NULL;
32939 }
32940
32941
32942 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32943 PyObject *resultobj = 0;
32944 wxWindow *arg1 = (wxWindow *) 0 ;
32945 bool result;
32946 void *argp1 = 0 ;
32947 int res1 = 0 ;
32948 PyObject *swig_obj[1] ;
32949
32950 if (!args) SWIG_fail;
32951 swig_obj[0] = args;
32952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32953 if (!SWIG_IsOK(res1)) {
32954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32955 }
32956 arg1 = reinterpret_cast< wxWindow * >(argp1);
32957 {
32958 PyThreadState* __tstate = wxPyBeginAllowThreads();
32959 result = (bool)(arg1)->Destroy();
32960 wxPyEndAllowThreads(__tstate);
32961 if (PyErr_Occurred()) SWIG_fail;
32962 }
32963 {
32964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32965 }
32966 return resultobj;
32967 fail:
32968 return NULL;
32969 }
32970
32971
32972 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32973 PyObject *resultobj = 0;
32974 wxWindow *arg1 = (wxWindow *) 0 ;
32975 bool result;
32976 void *argp1 = 0 ;
32977 int res1 = 0 ;
32978 PyObject *swig_obj[1] ;
32979
32980 if (!args) SWIG_fail;
32981 swig_obj[0] = args;
32982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32983 if (!SWIG_IsOK(res1)) {
32984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32985 }
32986 arg1 = reinterpret_cast< wxWindow * >(argp1);
32987 {
32988 PyThreadState* __tstate = wxPyBeginAllowThreads();
32989 result = (bool)(arg1)->DestroyChildren();
32990 wxPyEndAllowThreads(__tstate);
32991 if (PyErr_Occurred()) SWIG_fail;
32992 }
32993 {
32994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32995 }
32996 return resultobj;
32997 fail:
32998 return NULL;
32999 }
33000
33001
33002 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33003 PyObject *resultobj = 0;
33004 wxWindow *arg1 = (wxWindow *) 0 ;
33005 bool result;
33006 void *argp1 = 0 ;
33007 int res1 = 0 ;
33008 PyObject *swig_obj[1] ;
33009
33010 if (!args) SWIG_fail;
33011 swig_obj[0] = args;
33012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33013 if (!SWIG_IsOK(res1)) {
33014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33015 }
33016 arg1 = reinterpret_cast< wxWindow * >(argp1);
33017 {
33018 PyThreadState* __tstate = wxPyBeginAllowThreads();
33019 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33020 wxPyEndAllowThreads(__tstate);
33021 if (PyErr_Occurred()) SWIG_fail;
33022 }
33023 {
33024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33025 }
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33033 PyObject *resultobj = 0;
33034 wxWindow *arg1 = (wxWindow *) 0 ;
33035 wxString *arg2 = 0 ;
33036 void *argp1 = 0 ;
33037 int res1 = 0 ;
33038 bool temp2 = false ;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 char * kwnames[] = {
33042 (char *) "self",(char *) "label", NULL
33043 };
33044
33045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33049 }
33050 arg1 = reinterpret_cast< wxWindow * >(argp1);
33051 {
33052 arg2 = wxString_in_helper(obj1);
33053 if (arg2 == NULL) SWIG_fail;
33054 temp2 = true;
33055 }
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 (arg1)->SetLabel((wxString const &)*arg2);
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 resultobj = SWIG_Py_Void();
33063 {
33064 if (temp2)
33065 delete arg2;
33066 }
33067 return resultobj;
33068 fail:
33069 {
33070 if (temp2)
33071 delete arg2;
33072 }
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33078 PyObject *resultobj = 0;
33079 wxWindow *arg1 = (wxWindow *) 0 ;
33080 wxString result;
33081 void *argp1 = 0 ;
33082 int res1 = 0 ;
33083 PyObject *swig_obj[1] ;
33084
33085 if (!args) SWIG_fail;
33086 swig_obj[0] = args;
33087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33090 }
33091 arg1 = reinterpret_cast< wxWindow * >(argp1);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 result = ((wxWindow const *)arg1)->GetLabel();
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 {
33099 #if wxUSE_UNICODE
33100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33101 #else
33102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33103 #endif
33104 }
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj = 0;
33113 wxWindow *arg1 = (wxWindow *) 0 ;
33114 wxString *arg2 = 0 ;
33115 void *argp1 = 0 ;
33116 int res1 = 0 ;
33117 bool temp2 = false ;
33118 PyObject * obj0 = 0 ;
33119 PyObject * obj1 = 0 ;
33120 char * kwnames[] = {
33121 (char *) "self",(char *) "name", NULL
33122 };
33123
33124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33126 if (!SWIG_IsOK(res1)) {
33127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33128 }
33129 arg1 = reinterpret_cast< wxWindow * >(argp1);
33130 {
33131 arg2 = wxString_in_helper(obj1);
33132 if (arg2 == NULL) SWIG_fail;
33133 temp2 = true;
33134 }
33135 {
33136 PyThreadState* __tstate = wxPyBeginAllowThreads();
33137 (arg1)->SetName((wxString const &)*arg2);
33138 wxPyEndAllowThreads(__tstate);
33139 if (PyErr_Occurred()) SWIG_fail;
33140 }
33141 resultobj = SWIG_Py_Void();
33142 {
33143 if (temp2)
33144 delete arg2;
33145 }
33146 return resultobj;
33147 fail:
33148 {
33149 if (temp2)
33150 delete arg2;
33151 }
33152 return NULL;
33153 }
33154
33155
33156 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33157 PyObject *resultobj = 0;
33158 wxWindow *arg1 = (wxWindow *) 0 ;
33159 wxString result;
33160 void *argp1 = 0 ;
33161 int res1 = 0 ;
33162 PyObject *swig_obj[1] ;
33163
33164 if (!args) SWIG_fail;
33165 swig_obj[0] = args;
33166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33167 if (!SWIG_IsOK(res1)) {
33168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33169 }
33170 arg1 = reinterpret_cast< wxWindow * >(argp1);
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = ((wxWindow const *)arg1)->GetName();
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 {
33178 #if wxUSE_UNICODE
33179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33180 #else
33181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33182 #endif
33183 }
33184 return resultobj;
33185 fail:
33186 return NULL;
33187 }
33188
33189
33190 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33191 PyObject *resultobj = 0;
33192 wxWindow *arg1 = (wxWindow *) 0 ;
33193 wxWindowVariant arg2 ;
33194 void *argp1 = 0 ;
33195 int res1 = 0 ;
33196 int val2 ;
33197 int ecode2 = 0 ;
33198 PyObject * obj0 = 0 ;
33199 PyObject * obj1 = 0 ;
33200 char * kwnames[] = {
33201 (char *) "self",(char *) "variant", NULL
33202 };
33203
33204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33206 if (!SWIG_IsOK(res1)) {
33207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33208 }
33209 arg1 = reinterpret_cast< wxWindow * >(argp1);
33210 ecode2 = SWIG_AsVal_int(obj1, &val2);
33211 if (!SWIG_IsOK(ecode2)) {
33212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33213 }
33214 arg2 = static_cast< wxWindowVariant >(val2);
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 (arg1)->SetWindowVariant(arg2);
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 resultobj = SWIG_Py_Void();
33222 return resultobj;
33223 fail:
33224 return NULL;
33225 }
33226
33227
33228 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33229 PyObject *resultobj = 0;
33230 wxWindow *arg1 = (wxWindow *) 0 ;
33231 wxWindowVariant result;
33232 void *argp1 = 0 ;
33233 int res1 = 0 ;
33234 PyObject *swig_obj[1] ;
33235
33236 if (!args) SWIG_fail;
33237 swig_obj[0] = args;
33238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33239 if (!SWIG_IsOK(res1)) {
33240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33241 }
33242 arg1 = reinterpret_cast< wxWindow * >(argp1);
33243 {
33244 PyThreadState* __tstate = wxPyBeginAllowThreads();
33245 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 resultobj = SWIG_From_int(static_cast< int >(result));
33250 return resultobj;
33251 fail:
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33257 PyObject *resultobj = 0;
33258 wxWindow *arg1 = (wxWindow *) 0 ;
33259 int arg2 ;
33260 void *argp1 = 0 ;
33261 int res1 = 0 ;
33262 int val2 ;
33263 int ecode2 = 0 ;
33264 PyObject * obj0 = 0 ;
33265 PyObject * obj1 = 0 ;
33266 char * kwnames[] = {
33267 (char *) "self",(char *) "winid", NULL
33268 };
33269
33270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33272 if (!SWIG_IsOK(res1)) {
33273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33274 }
33275 arg1 = reinterpret_cast< wxWindow * >(argp1);
33276 ecode2 = SWIG_AsVal_int(obj1, &val2);
33277 if (!SWIG_IsOK(ecode2)) {
33278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33279 }
33280 arg2 = static_cast< int >(val2);
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 (arg1)->SetId(arg2);
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 resultobj = SWIG_Py_Void();
33288 return resultobj;
33289 fail:
33290 return NULL;
33291 }
33292
33293
33294 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33295 PyObject *resultobj = 0;
33296 wxWindow *arg1 = (wxWindow *) 0 ;
33297 int result;
33298 void *argp1 = 0 ;
33299 int res1 = 0 ;
33300 PyObject *swig_obj[1] ;
33301
33302 if (!args) SWIG_fail;
33303 swig_obj[0] = args;
33304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33305 if (!SWIG_IsOK(res1)) {
33306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33307 }
33308 arg1 = reinterpret_cast< wxWindow * >(argp1);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 result = (int)((wxWindow const *)arg1)->GetId();
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 resultobj = SWIG_From_int(static_cast< int >(result));
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33323 PyObject *resultobj = 0;
33324 int result;
33325
33326 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (int)wxWindow::NewControlId();
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 resultobj = SWIG_From_int(static_cast< int >(result));
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj = 0;
33342 int arg1 ;
33343 int result;
33344 int val1 ;
33345 int ecode1 = 0 ;
33346 PyObject * obj0 = 0 ;
33347 char * kwnames[] = {
33348 (char *) "winid", NULL
33349 };
33350
33351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33352 ecode1 = SWIG_AsVal_int(obj0, &val1);
33353 if (!SWIG_IsOK(ecode1)) {
33354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33355 }
33356 arg1 = static_cast< int >(val1);
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 result = (int)wxWindow::NextControlId(arg1);
33360 wxPyEndAllowThreads(__tstate);
33361 if (PyErr_Occurred()) SWIG_fail;
33362 }
33363 resultobj = SWIG_From_int(static_cast< int >(result));
33364 return resultobj;
33365 fail:
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33371 PyObject *resultobj = 0;
33372 int arg1 ;
33373 int result;
33374 int val1 ;
33375 int ecode1 = 0 ;
33376 PyObject * obj0 = 0 ;
33377 char * kwnames[] = {
33378 (char *) "winid", NULL
33379 };
33380
33381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33382 ecode1 = SWIG_AsVal_int(obj0, &val1);
33383 if (!SWIG_IsOK(ecode1)) {
33384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33385 }
33386 arg1 = static_cast< int >(val1);
33387 {
33388 PyThreadState* __tstate = wxPyBeginAllowThreads();
33389 result = (int)wxWindow::PrevControlId(arg1);
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 resultobj = SWIG_From_int(static_cast< int >(result));
33394 return resultobj;
33395 fail:
33396 return NULL;
33397 }
33398
33399
33400 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33401 PyObject *resultobj = 0;
33402 wxWindow *arg1 = (wxWindow *) 0 ;
33403 wxLayoutDirection result;
33404 void *argp1 = 0 ;
33405 int res1 = 0 ;
33406 PyObject *swig_obj[1] ;
33407
33408 if (!args) SWIG_fail;
33409 swig_obj[0] = args;
33410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33411 if (!SWIG_IsOK(res1)) {
33412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33413 }
33414 arg1 = reinterpret_cast< wxWindow * >(argp1);
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33418 wxPyEndAllowThreads(__tstate);
33419 if (PyErr_Occurred()) SWIG_fail;
33420 }
33421 resultobj = SWIG_From_int(static_cast< int >(result));
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33429 PyObject *resultobj = 0;
33430 wxWindow *arg1 = (wxWindow *) 0 ;
33431 wxLayoutDirection arg2 ;
33432 void *argp1 = 0 ;
33433 int res1 = 0 ;
33434 int val2 ;
33435 int ecode2 = 0 ;
33436 PyObject * obj0 = 0 ;
33437 PyObject * obj1 = 0 ;
33438 char * kwnames[] = {
33439 (char *) "self",(char *) "dir", NULL
33440 };
33441
33442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33444 if (!SWIG_IsOK(res1)) {
33445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33446 }
33447 arg1 = reinterpret_cast< wxWindow * >(argp1);
33448 ecode2 = SWIG_AsVal_int(obj1, &val2);
33449 if (!SWIG_IsOK(ecode2)) {
33450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33451 }
33452 arg2 = static_cast< wxLayoutDirection >(val2);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 (arg1)->SetLayoutDirection(arg2);
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_Py_Void();
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33467 PyObject *resultobj = 0;
33468 wxWindow *arg1 = (wxWindow *) 0 ;
33469 int arg2 ;
33470 int arg3 ;
33471 int arg4 ;
33472 int result;
33473 void *argp1 = 0 ;
33474 int res1 = 0 ;
33475 int val2 ;
33476 int ecode2 = 0 ;
33477 int val3 ;
33478 int ecode3 = 0 ;
33479 int val4 ;
33480 int ecode4 = 0 ;
33481 PyObject * obj0 = 0 ;
33482 PyObject * obj1 = 0 ;
33483 PyObject * obj2 = 0 ;
33484 PyObject * obj3 = 0 ;
33485 char * kwnames[] = {
33486 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33487 };
33488
33489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33491 if (!SWIG_IsOK(res1)) {
33492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33493 }
33494 arg1 = reinterpret_cast< wxWindow * >(argp1);
33495 ecode2 = SWIG_AsVal_int(obj1, &val2);
33496 if (!SWIG_IsOK(ecode2)) {
33497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33498 }
33499 arg2 = static_cast< int >(val2);
33500 ecode3 = SWIG_AsVal_int(obj2, &val3);
33501 if (!SWIG_IsOK(ecode3)) {
33502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33503 }
33504 arg3 = static_cast< int >(val3);
33505 ecode4 = SWIG_AsVal_int(obj3, &val4);
33506 if (!SWIG_IsOK(ecode4)) {
33507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33508 }
33509 arg4 = static_cast< int >(val4);
33510 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33513 wxPyEndAllowThreads(__tstate);
33514 if (PyErr_Occurred()) SWIG_fail;
33515 }
33516 resultobj = SWIG_From_int(static_cast< int >(result));
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33524 PyObject *resultobj = 0;
33525 wxWindow *arg1 = (wxWindow *) 0 ;
33526 wxSize *arg2 = 0 ;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 wxSize temp2 ;
33530 PyObject * obj0 = 0 ;
33531 PyObject * obj1 = 0 ;
33532 char * kwnames[] = {
33533 (char *) "self",(char *) "size", NULL
33534 };
33535
33536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33538 if (!SWIG_IsOK(res1)) {
33539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33540 }
33541 arg1 = reinterpret_cast< wxWindow * >(argp1);
33542 {
33543 arg2 = &temp2;
33544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33545 }
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 (arg1)->SetSize((wxSize const &)*arg2);
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 resultobj = SWIG_Py_Void();
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 int arg2 ;
33563 int arg3 ;
33564 int arg4 ;
33565 int arg5 ;
33566 int arg6 = (int) wxSIZE_AUTO ;
33567 void *argp1 = 0 ;
33568 int res1 = 0 ;
33569 int val2 ;
33570 int ecode2 = 0 ;
33571 int val3 ;
33572 int ecode3 = 0 ;
33573 int val4 ;
33574 int ecode4 = 0 ;
33575 int val5 ;
33576 int ecode5 = 0 ;
33577 int val6 ;
33578 int ecode6 = 0 ;
33579 PyObject * obj0 = 0 ;
33580 PyObject * obj1 = 0 ;
33581 PyObject * obj2 = 0 ;
33582 PyObject * obj3 = 0 ;
33583 PyObject * obj4 = 0 ;
33584 PyObject * obj5 = 0 ;
33585 char * kwnames[] = {
33586 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33587 };
33588
33589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33591 if (!SWIG_IsOK(res1)) {
33592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33593 }
33594 arg1 = reinterpret_cast< wxWindow * >(argp1);
33595 ecode2 = SWIG_AsVal_int(obj1, &val2);
33596 if (!SWIG_IsOK(ecode2)) {
33597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33598 }
33599 arg2 = static_cast< int >(val2);
33600 ecode3 = SWIG_AsVal_int(obj2, &val3);
33601 if (!SWIG_IsOK(ecode3)) {
33602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33603 }
33604 arg3 = static_cast< int >(val3);
33605 ecode4 = SWIG_AsVal_int(obj3, &val4);
33606 if (!SWIG_IsOK(ecode4)) {
33607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33608 }
33609 arg4 = static_cast< int >(val4);
33610 ecode5 = SWIG_AsVal_int(obj4, &val5);
33611 if (!SWIG_IsOK(ecode5)) {
33612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33613 }
33614 arg5 = static_cast< int >(val5);
33615 if (obj5) {
33616 ecode6 = SWIG_AsVal_int(obj5, &val6);
33617 if (!SWIG_IsOK(ecode6)) {
33618 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33619 }
33620 arg6 = static_cast< int >(val6);
33621 }
33622 {
33623 PyThreadState* __tstate = wxPyBeginAllowThreads();
33624 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 resultobj = SWIG_Py_Void();
33629 return resultobj;
33630 fail:
33631 return NULL;
33632 }
33633
33634
33635 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33636 PyObject *resultobj = 0;
33637 wxWindow *arg1 = (wxWindow *) 0 ;
33638 wxRect *arg2 = 0 ;
33639 int arg3 = (int) wxSIZE_AUTO ;
33640 void *argp1 = 0 ;
33641 int res1 = 0 ;
33642 wxRect temp2 ;
33643 int val3 ;
33644 int ecode3 = 0 ;
33645 PyObject * obj0 = 0 ;
33646 PyObject * obj1 = 0 ;
33647 PyObject * obj2 = 0 ;
33648 char * kwnames[] = {
33649 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33650 };
33651
33652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33654 if (!SWIG_IsOK(res1)) {
33655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33656 }
33657 arg1 = reinterpret_cast< wxWindow * >(argp1);
33658 {
33659 arg2 = &temp2;
33660 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33661 }
33662 if (obj2) {
33663 ecode3 = SWIG_AsVal_int(obj2, &val3);
33664 if (!SWIG_IsOK(ecode3)) {
33665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33666 }
33667 arg3 = static_cast< int >(val3);
33668 }
33669 {
33670 PyThreadState* __tstate = wxPyBeginAllowThreads();
33671 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33672 wxPyEndAllowThreads(__tstate);
33673 if (PyErr_Occurred()) SWIG_fail;
33674 }
33675 resultobj = SWIG_Py_Void();
33676 return resultobj;
33677 fail:
33678 return NULL;
33679 }
33680
33681
33682 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33683 PyObject *resultobj = 0;
33684 wxWindow *arg1 = (wxWindow *) 0 ;
33685 int arg2 ;
33686 int arg3 ;
33687 void *argp1 = 0 ;
33688 int res1 = 0 ;
33689 int val2 ;
33690 int ecode2 = 0 ;
33691 int val3 ;
33692 int ecode3 = 0 ;
33693 PyObject * obj0 = 0 ;
33694 PyObject * obj1 = 0 ;
33695 PyObject * obj2 = 0 ;
33696 char * kwnames[] = {
33697 (char *) "self",(char *) "width",(char *) "height", NULL
33698 };
33699
33700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33702 if (!SWIG_IsOK(res1)) {
33703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33704 }
33705 arg1 = reinterpret_cast< wxWindow * >(argp1);
33706 ecode2 = SWIG_AsVal_int(obj1, &val2);
33707 if (!SWIG_IsOK(ecode2)) {
33708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33709 }
33710 arg2 = static_cast< int >(val2);
33711 ecode3 = SWIG_AsVal_int(obj2, &val3);
33712 if (!SWIG_IsOK(ecode3)) {
33713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33714 }
33715 arg3 = static_cast< int >(val3);
33716 {
33717 PyThreadState* __tstate = wxPyBeginAllowThreads();
33718 (arg1)->SetSize(arg2,arg3);
33719 wxPyEndAllowThreads(__tstate);
33720 if (PyErr_Occurred()) SWIG_fail;
33721 }
33722 resultobj = SWIG_Py_Void();
33723 return resultobj;
33724 fail:
33725 return NULL;
33726 }
33727
33728
33729 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33730 PyObject *resultobj = 0;
33731 wxWindow *arg1 = (wxWindow *) 0 ;
33732 wxPoint *arg2 = 0 ;
33733 int arg3 = (int) wxSIZE_USE_EXISTING ;
33734 void *argp1 = 0 ;
33735 int res1 = 0 ;
33736 wxPoint temp2 ;
33737 int val3 ;
33738 int ecode3 = 0 ;
33739 PyObject * obj0 = 0 ;
33740 PyObject * obj1 = 0 ;
33741 PyObject * obj2 = 0 ;
33742 char * kwnames[] = {
33743 (char *) "self",(char *) "pt",(char *) "flags", NULL
33744 };
33745
33746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33748 if (!SWIG_IsOK(res1)) {
33749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33750 }
33751 arg1 = reinterpret_cast< wxWindow * >(argp1);
33752 {
33753 arg2 = &temp2;
33754 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33755 }
33756 if (obj2) {
33757 ecode3 = SWIG_AsVal_int(obj2, &val3);
33758 if (!SWIG_IsOK(ecode3)) {
33759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33760 }
33761 arg3 = static_cast< int >(val3);
33762 }
33763 {
33764 PyThreadState* __tstate = wxPyBeginAllowThreads();
33765 (arg1)->Move((wxPoint const &)*arg2,arg3);
33766 wxPyEndAllowThreads(__tstate);
33767 if (PyErr_Occurred()) SWIG_fail;
33768 }
33769 resultobj = SWIG_Py_Void();
33770 return resultobj;
33771 fail:
33772 return NULL;
33773 }
33774
33775
33776 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33777 PyObject *resultobj = 0;
33778 wxWindow *arg1 = (wxWindow *) 0 ;
33779 int arg2 ;
33780 int arg3 ;
33781 int arg4 = (int) wxSIZE_USE_EXISTING ;
33782 void *argp1 = 0 ;
33783 int res1 = 0 ;
33784 int val2 ;
33785 int ecode2 = 0 ;
33786 int val3 ;
33787 int ecode3 = 0 ;
33788 int val4 ;
33789 int ecode4 = 0 ;
33790 PyObject * obj0 = 0 ;
33791 PyObject * obj1 = 0 ;
33792 PyObject * obj2 = 0 ;
33793 PyObject * obj3 = 0 ;
33794 char * kwnames[] = {
33795 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33796 };
33797
33798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33802 }
33803 arg1 = reinterpret_cast< wxWindow * >(argp1);
33804 ecode2 = SWIG_AsVal_int(obj1, &val2);
33805 if (!SWIG_IsOK(ecode2)) {
33806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33807 }
33808 arg2 = static_cast< int >(val2);
33809 ecode3 = SWIG_AsVal_int(obj2, &val3);
33810 if (!SWIG_IsOK(ecode3)) {
33811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33812 }
33813 arg3 = static_cast< int >(val3);
33814 if (obj3) {
33815 ecode4 = SWIG_AsVal_int(obj3, &val4);
33816 if (!SWIG_IsOK(ecode4)) {
33817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33818 }
33819 arg4 = static_cast< int >(val4);
33820 }
33821 {
33822 PyThreadState* __tstate = wxPyBeginAllowThreads();
33823 (arg1)->Move(arg2,arg3,arg4);
33824 wxPyEndAllowThreads(__tstate);
33825 if (PyErr_Occurred()) SWIG_fail;
33826 }
33827 resultobj = SWIG_Py_Void();
33828 return resultobj;
33829 fail:
33830 return NULL;
33831 }
33832
33833
33834 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33835 PyObject *resultobj = 0;
33836 wxWindow *arg1 = (wxWindow *) 0 ;
33837 wxSize const &arg2_defvalue = wxDefaultSize ;
33838 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33839 void *argp1 = 0 ;
33840 int res1 = 0 ;
33841 wxSize temp2 ;
33842 PyObject * obj0 = 0 ;
33843 PyObject * obj1 = 0 ;
33844 char * kwnames[] = {
33845 (char *) "self",(char *) "size", NULL
33846 };
33847
33848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33850 if (!SWIG_IsOK(res1)) {
33851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33852 }
33853 arg1 = reinterpret_cast< wxWindow * >(argp1);
33854 if (obj1) {
33855 {
33856 arg2 = &temp2;
33857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33858 }
33859 }
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 (arg1)->SetInitialSize((wxSize const &)*arg2);
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 resultobj = SWIG_Py_Void();
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 void *argp1 = 0 ;
33877 int res1 = 0 ;
33878 PyObject *swig_obj[1] ;
33879
33880 if (!args) SWIG_fail;
33881 swig_obj[0] = args;
33882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33885 }
33886 arg1 = reinterpret_cast< wxWindow * >(argp1);
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 (arg1)->Raise();
33890 wxPyEndAllowThreads(__tstate);
33891 if (PyErr_Occurred()) SWIG_fail;
33892 }
33893 resultobj = SWIG_Py_Void();
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33901 PyObject *resultobj = 0;
33902 wxWindow *arg1 = (wxWindow *) 0 ;
33903 void *argp1 = 0 ;
33904 int res1 = 0 ;
33905 PyObject *swig_obj[1] ;
33906
33907 if (!args) SWIG_fail;
33908 swig_obj[0] = args;
33909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33910 if (!SWIG_IsOK(res1)) {
33911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33912 }
33913 arg1 = reinterpret_cast< wxWindow * >(argp1);
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 (arg1)->Lower();
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 resultobj = SWIG_Py_Void();
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33928 PyObject *resultobj = 0;
33929 wxWindow *arg1 = (wxWindow *) 0 ;
33930 wxSize *arg2 = 0 ;
33931 void *argp1 = 0 ;
33932 int res1 = 0 ;
33933 wxSize temp2 ;
33934 PyObject * obj0 = 0 ;
33935 PyObject * obj1 = 0 ;
33936 char * kwnames[] = {
33937 (char *) "self",(char *) "size", NULL
33938 };
33939
33940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33942 if (!SWIG_IsOK(res1)) {
33943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33944 }
33945 arg1 = reinterpret_cast< wxWindow * >(argp1);
33946 {
33947 arg2 = &temp2;
33948 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33949 }
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 (arg1)->SetClientSize((wxSize const &)*arg2);
33953 wxPyEndAllowThreads(__tstate);
33954 if (PyErr_Occurred()) SWIG_fail;
33955 }
33956 resultobj = SWIG_Py_Void();
33957 return resultobj;
33958 fail:
33959 return NULL;
33960 }
33961
33962
33963 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33964 PyObject *resultobj = 0;
33965 wxWindow *arg1 = (wxWindow *) 0 ;
33966 int arg2 ;
33967 int arg3 ;
33968 void *argp1 = 0 ;
33969 int res1 = 0 ;
33970 int val2 ;
33971 int ecode2 = 0 ;
33972 int val3 ;
33973 int ecode3 = 0 ;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 PyObject * obj2 = 0 ;
33977 char * kwnames[] = {
33978 (char *) "self",(char *) "width",(char *) "height", NULL
33979 };
33980
33981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33983 if (!SWIG_IsOK(res1)) {
33984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33985 }
33986 arg1 = reinterpret_cast< wxWindow * >(argp1);
33987 ecode2 = SWIG_AsVal_int(obj1, &val2);
33988 if (!SWIG_IsOK(ecode2)) {
33989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33990 }
33991 arg2 = static_cast< int >(val2);
33992 ecode3 = SWIG_AsVal_int(obj2, &val3);
33993 if (!SWIG_IsOK(ecode3)) {
33994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33995 }
33996 arg3 = static_cast< int >(val3);
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->SetClientSize(arg2,arg3);
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_Py_Void();
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34011 PyObject *resultobj = 0;
34012 wxWindow *arg1 = (wxWindow *) 0 ;
34013 wxRect *arg2 = 0 ;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 wxRect temp2 ;
34017 PyObject * obj0 = 0 ;
34018 PyObject * obj1 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "self",(char *) "rect", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34027 }
34028 arg1 = reinterpret_cast< wxWindow * >(argp1);
34029 {
34030 arg2 = &temp2;
34031 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34032 }
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 (arg1)->SetClientSize((wxRect const &)*arg2);
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 resultobj = SWIG_Py_Void();
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34047 PyObject *resultobj = 0;
34048 wxWindow *arg1 = (wxWindow *) 0 ;
34049 wxPoint result;
34050 void *argp1 = 0 ;
34051 int res1 = 0 ;
34052 PyObject *swig_obj[1] ;
34053
34054 if (!args) SWIG_fail;
34055 swig_obj[0] = args;
34056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34057 if (!SWIG_IsOK(res1)) {
34058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34059 }
34060 arg1 = reinterpret_cast< wxWindow * >(argp1);
34061 {
34062 PyThreadState* __tstate = wxPyBeginAllowThreads();
34063 result = ((wxWindow const *)arg1)->GetPosition();
34064 wxPyEndAllowThreads(__tstate);
34065 if (PyErr_Occurred()) SWIG_fail;
34066 }
34067 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34068 return resultobj;
34069 fail:
34070 return NULL;
34071 }
34072
34073
34074 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34075 PyObject *resultobj = 0;
34076 wxWindow *arg1 = (wxWindow *) 0 ;
34077 int *arg2 = (int *) 0 ;
34078 int *arg3 = (int *) 0 ;
34079 void *argp1 = 0 ;
34080 int res1 = 0 ;
34081 int temp2 ;
34082 int res2 = SWIG_TMPOBJ ;
34083 int temp3 ;
34084 int res3 = SWIG_TMPOBJ ;
34085 PyObject *swig_obj[1] ;
34086
34087 arg2 = &temp2;
34088 arg3 = &temp3;
34089 if (!args) SWIG_fail;
34090 swig_obj[0] = args;
34091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34092 if (!SWIG_IsOK(res1)) {
34093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34094 }
34095 arg1 = reinterpret_cast< wxWindow * >(argp1);
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 resultobj = SWIG_Py_Void();
34103 if (SWIG_IsTmpObj(res2)) {
34104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34105 } else {
34106 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34108 }
34109 if (SWIG_IsTmpObj(res3)) {
34110 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34111 } else {
34112 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34113 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34114 }
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34122 PyObject *resultobj = 0;
34123 wxWindow *arg1 = (wxWindow *) 0 ;
34124 wxPoint result;
34125 void *argp1 = 0 ;
34126 int res1 = 0 ;
34127 PyObject *swig_obj[1] ;
34128
34129 if (!args) SWIG_fail;
34130 swig_obj[0] = args;
34131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34132 if (!SWIG_IsOK(res1)) {
34133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34134 }
34135 arg1 = reinterpret_cast< wxWindow * >(argp1);
34136 {
34137 PyThreadState* __tstate = wxPyBeginAllowThreads();
34138 result = ((wxWindow const *)arg1)->GetScreenPosition();
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34150 PyObject *resultobj = 0;
34151 wxWindow *arg1 = (wxWindow *) 0 ;
34152 int *arg2 = (int *) 0 ;
34153 int *arg3 = (int *) 0 ;
34154 void *argp1 = 0 ;
34155 int res1 = 0 ;
34156 int temp2 ;
34157 int res2 = SWIG_TMPOBJ ;
34158 int temp3 ;
34159 int res3 = SWIG_TMPOBJ ;
34160 PyObject *swig_obj[1] ;
34161
34162 arg2 = &temp2;
34163 arg3 = &temp3;
34164 if (!args) SWIG_fail;
34165 swig_obj[0] = args;
34166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34167 if (!SWIG_IsOK(res1)) {
34168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34169 }
34170 arg1 = reinterpret_cast< wxWindow * >(argp1);
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34174 wxPyEndAllowThreads(__tstate);
34175 if (PyErr_Occurred()) SWIG_fail;
34176 }
34177 resultobj = SWIG_Py_Void();
34178 if (SWIG_IsTmpObj(res2)) {
34179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34180 } else {
34181 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34183 }
34184 if (SWIG_IsTmpObj(res3)) {
34185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34186 } else {
34187 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34189 }
34190 return resultobj;
34191 fail:
34192 return NULL;
34193 }
34194
34195
34196 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34197 PyObject *resultobj = 0;
34198 wxWindow *arg1 = (wxWindow *) 0 ;
34199 wxRect result;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 PyObject *swig_obj[1] ;
34203
34204 if (!args) SWIG_fail;
34205 swig_obj[0] = args;
34206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34209 }
34210 arg1 = reinterpret_cast< wxWindow * >(argp1);
34211 {
34212 PyThreadState* __tstate = wxPyBeginAllowThreads();
34213 result = ((wxWindow const *)arg1)->GetScreenRect();
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34225 PyObject *resultobj = 0;
34226 wxWindow *arg1 = (wxWindow *) 0 ;
34227 wxSize result;
34228 void *argp1 = 0 ;
34229 int res1 = 0 ;
34230 PyObject *swig_obj[1] ;
34231
34232 if (!args) SWIG_fail;
34233 swig_obj[0] = args;
34234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34235 if (!SWIG_IsOK(res1)) {
34236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34237 }
34238 arg1 = reinterpret_cast< wxWindow * >(argp1);
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 result = ((wxWindow const *)arg1)->GetSize();
34242 wxPyEndAllowThreads(__tstate);
34243 if (PyErr_Occurred()) SWIG_fail;
34244 }
34245 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34246 return resultobj;
34247 fail:
34248 return NULL;
34249 }
34250
34251
34252 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34253 PyObject *resultobj = 0;
34254 wxWindow *arg1 = (wxWindow *) 0 ;
34255 int *arg2 = (int *) 0 ;
34256 int *arg3 = (int *) 0 ;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 int temp2 ;
34260 int res2 = SWIG_TMPOBJ ;
34261 int temp3 ;
34262 int res3 = SWIG_TMPOBJ ;
34263 PyObject *swig_obj[1] ;
34264
34265 arg2 = &temp2;
34266 arg3 = &temp3;
34267 if (!args) SWIG_fail;
34268 swig_obj[0] = args;
34269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34270 if (!SWIG_IsOK(res1)) {
34271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34272 }
34273 arg1 = reinterpret_cast< wxWindow * >(argp1);
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 resultobj = SWIG_Py_Void();
34281 if (SWIG_IsTmpObj(res2)) {
34282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34283 } else {
34284 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34286 }
34287 if (SWIG_IsTmpObj(res3)) {
34288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34289 } else {
34290 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34292 }
34293 return resultobj;
34294 fail:
34295 return NULL;
34296 }
34297
34298
34299 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34300 PyObject *resultobj = 0;
34301 wxWindow *arg1 = (wxWindow *) 0 ;
34302 wxRect result;
34303 void *argp1 = 0 ;
34304 int res1 = 0 ;
34305 PyObject *swig_obj[1] ;
34306
34307 if (!args) SWIG_fail;
34308 swig_obj[0] = args;
34309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34310 if (!SWIG_IsOK(res1)) {
34311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34312 }
34313 arg1 = reinterpret_cast< wxWindow * >(argp1);
34314 {
34315 PyThreadState* __tstate = wxPyBeginAllowThreads();
34316 result = ((wxWindow const *)arg1)->GetRect();
34317 wxPyEndAllowThreads(__tstate);
34318 if (PyErr_Occurred()) SWIG_fail;
34319 }
34320 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34321 return resultobj;
34322 fail:
34323 return NULL;
34324 }
34325
34326
34327 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34328 PyObject *resultobj = 0;
34329 wxWindow *arg1 = (wxWindow *) 0 ;
34330 wxSize result;
34331 void *argp1 = 0 ;
34332 int res1 = 0 ;
34333 PyObject *swig_obj[1] ;
34334
34335 if (!args) SWIG_fail;
34336 swig_obj[0] = args;
34337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34338 if (!SWIG_IsOK(res1)) {
34339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34340 }
34341 arg1 = reinterpret_cast< wxWindow * >(argp1);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 result = ((wxWindow const *)arg1)->GetClientSize();
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34356 PyObject *resultobj = 0;
34357 wxWindow *arg1 = (wxWindow *) 0 ;
34358 int *arg2 = (int *) 0 ;
34359 int *arg3 = (int *) 0 ;
34360 void *argp1 = 0 ;
34361 int res1 = 0 ;
34362 int temp2 ;
34363 int res2 = SWIG_TMPOBJ ;
34364 int temp3 ;
34365 int res3 = SWIG_TMPOBJ ;
34366 PyObject *swig_obj[1] ;
34367
34368 arg2 = &temp2;
34369 arg3 = &temp3;
34370 if (!args) SWIG_fail;
34371 swig_obj[0] = args;
34372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34373 if (!SWIG_IsOK(res1)) {
34374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34375 }
34376 arg1 = reinterpret_cast< wxWindow * >(argp1);
34377 {
34378 PyThreadState* __tstate = wxPyBeginAllowThreads();
34379 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34380 wxPyEndAllowThreads(__tstate);
34381 if (PyErr_Occurred()) SWIG_fail;
34382 }
34383 resultobj = SWIG_Py_Void();
34384 if (SWIG_IsTmpObj(res2)) {
34385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34386 } else {
34387 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34389 }
34390 if (SWIG_IsTmpObj(res3)) {
34391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34392 } else {
34393 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34395 }
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 wxPoint result;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 PyObject *swig_obj[1] ;
34409
34410 if (!args) SWIG_fail;
34411 swig_obj[0] = args;
34412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34413 if (!SWIG_IsOK(res1)) {
34414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34415 }
34416 arg1 = reinterpret_cast< wxWindow * >(argp1);
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34420 wxPyEndAllowThreads(__tstate);
34421 if (PyErr_Occurred()) SWIG_fail;
34422 }
34423 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34424 return resultobj;
34425 fail:
34426 return NULL;
34427 }
34428
34429
34430 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34431 PyObject *resultobj = 0;
34432 wxWindow *arg1 = (wxWindow *) 0 ;
34433 wxRect result;
34434 void *argp1 = 0 ;
34435 int res1 = 0 ;
34436 PyObject *swig_obj[1] ;
34437
34438 if (!args) SWIG_fail;
34439 swig_obj[0] = args;
34440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34441 if (!SWIG_IsOK(res1)) {
34442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34443 }
34444 arg1 = reinterpret_cast< wxWindow * >(argp1);
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 result = ((wxWindow const *)arg1)->GetClientRect();
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34459 PyObject *resultobj = 0;
34460 wxWindow *arg1 = (wxWindow *) 0 ;
34461 wxSize result;
34462 void *argp1 = 0 ;
34463 int res1 = 0 ;
34464 PyObject *swig_obj[1] ;
34465
34466 if (!args) SWIG_fail;
34467 swig_obj[0] = args;
34468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34469 if (!SWIG_IsOK(res1)) {
34470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34471 }
34472 arg1 = reinterpret_cast< wxWindow * >(argp1);
34473 {
34474 PyThreadState* __tstate = wxPyBeginAllowThreads();
34475 result = ((wxWindow const *)arg1)->GetBestSize();
34476 wxPyEndAllowThreads(__tstate);
34477 if (PyErr_Occurred()) SWIG_fail;
34478 }
34479 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34480 return resultobj;
34481 fail:
34482 return NULL;
34483 }
34484
34485
34486 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34487 PyObject *resultobj = 0;
34488 wxWindow *arg1 = (wxWindow *) 0 ;
34489 int *arg2 = (int *) 0 ;
34490 int *arg3 = (int *) 0 ;
34491 void *argp1 = 0 ;
34492 int res1 = 0 ;
34493 int temp2 ;
34494 int res2 = SWIG_TMPOBJ ;
34495 int temp3 ;
34496 int res3 = SWIG_TMPOBJ ;
34497 PyObject *swig_obj[1] ;
34498
34499 arg2 = &temp2;
34500 arg3 = &temp3;
34501 if (!args) SWIG_fail;
34502 swig_obj[0] = args;
34503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34504 if (!SWIG_IsOK(res1)) {
34505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34506 }
34507 arg1 = reinterpret_cast< wxWindow * >(argp1);
34508 {
34509 PyThreadState* __tstate = wxPyBeginAllowThreads();
34510 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34511 wxPyEndAllowThreads(__tstate);
34512 if (PyErr_Occurred()) SWIG_fail;
34513 }
34514 resultobj = SWIG_Py_Void();
34515 if (SWIG_IsTmpObj(res2)) {
34516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34517 } else {
34518 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34520 }
34521 if (SWIG_IsTmpObj(res3)) {
34522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34523 } else {
34524 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34526 }
34527 return resultobj;
34528 fail:
34529 return NULL;
34530 }
34531
34532
34533 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34534 PyObject *resultobj = 0;
34535 wxWindow *arg1 = (wxWindow *) 0 ;
34536 void *argp1 = 0 ;
34537 int res1 = 0 ;
34538 PyObject *swig_obj[1] ;
34539
34540 if (!args) SWIG_fail;
34541 swig_obj[0] = args;
34542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34543 if (!SWIG_IsOK(res1)) {
34544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34545 }
34546 arg1 = reinterpret_cast< wxWindow * >(argp1);
34547 {
34548 PyThreadState* __tstate = wxPyBeginAllowThreads();
34549 (arg1)->InvalidateBestSize();
34550 wxPyEndAllowThreads(__tstate);
34551 if (PyErr_Occurred()) SWIG_fail;
34552 }
34553 resultobj = SWIG_Py_Void();
34554 return resultobj;
34555 fail:
34556 return NULL;
34557 }
34558
34559
34560 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34561 PyObject *resultobj = 0;
34562 wxWindow *arg1 = (wxWindow *) 0 ;
34563 wxSize *arg2 = 0 ;
34564 void *argp1 = 0 ;
34565 int res1 = 0 ;
34566 wxSize temp2 ;
34567 PyObject * obj0 = 0 ;
34568 PyObject * obj1 = 0 ;
34569 char * kwnames[] = {
34570 (char *) "self",(char *) "size", NULL
34571 };
34572
34573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34577 }
34578 arg1 = reinterpret_cast< wxWindow * >(argp1);
34579 {
34580 arg2 = &temp2;
34581 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34582 }
34583 {
34584 PyThreadState* __tstate = wxPyBeginAllowThreads();
34585 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34586 wxPyEndAllowThreads(__tstate);
34587 if (PyErr_Occurred()) SWIG_fail;
34588 }
34589 resultobj = SWIG_Py_Void();
34590 return resultobj;
34591 fail:
34592 return NULL;
34593 }
34594
34595
34596 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34597 PyObject *resultobj = 0;
34598 wxWindow *arg1 = (wxWindow *) 0 ;
34599 wxSize result;
34600 void *argp1 = 0 ;
34601 int res1 = 0 ;
34602 PyObject *swig_obj[1] ;
34603
34604 if (!args) SWIG_fail;
34605 swig_obj[0] = args;
34606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34607 if (!SWIG_IsOK(res1)) {
34608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34609 }
34610 arg1 = reinterpret_cast< wxWindow * >(argp1);
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34614 wxPyEndAllowThreads(__tstate);
34615 if (PyErr_Occurred()) SWIG_fail;
34616 }
34617 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34618 return resultobj;
34619 fail:
34620 return NULL;
34621 }
34622
34623
34624 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34625 PyObject *resultobj = 0;
34626 wxWindow *arg1 = (wxWindow *) 0 ;
34627 int arg2 = (int) wxBOTH ;
34628 void *argp1 = 0 ;
34629 int res1 = 0 ;
34630 int val2 ;
34631 int ecode2 = 0 ;
34632 PyObject * obj0 = 0 ;
34633 PyObject * obj1 = 0 ;
34634 char * kwnames[] = {
34635 (char *) "self",(char *) "direction", NULL
34636 };
34637
34638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34640 if (!SWIG_IsOK(res1)) {
34641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34642 }
34643 arg1 = reinterpret_cast< wxWindow * >(argp1);
34644 if (obj1) {
34645 ecode2 = SWIG_AsVal_int(obj1, &val2);
34646 if (!SWIG_IsOK(ecode2)) {
34647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34648 }
34649 arg2 = static_cast< int >(val2);
34650 }
34651 {
34652 PyThreadState* __tstate = wxPyBeginAllowThreads();
34653 (arg1)->Center(arg2);
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 resultobj = SWIG_Py_Void();
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj = 0;
34666 wxWindow *arg1 = (wxWindow *) 0 ;
34667 int arg2 = (int) wxBOTH ;
34668 void *argp1 = 0 ;
34669 int res1 = 0 ;
34670 int val2 ;
34671 int ecode2 = 0 ;
34672 PyObject * obj0 = 0 ;
34673 PyObject * obj1 = 0 ;
34674 char * kwnames[] = {
34675 (char *) "self",(char *) "dir", NULL
34676 };
34677
34678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34680 if (!SWIG_IsOK(res1)) {
34681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34682 }
34683 arg1 = reinterpret_cast< wxWindow * >(argp1);
34684 if (obj1) {
34685 ecode2 = SWIG_AsVal_int(obj1, &val2);
34686 if (!SWIG_IsOK(ecode2)) {
34687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34688 }
34689 arg2 = static_cast< int >(val2);
34690 }
34691 {
34692 PyThreadState* __tstate = wxPyBeginAllowThreads();
34693 (arg1)->CenterOnParent(arg2);
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 resultobj = SWIG_Py_Void();
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34705 PyObject *resultobj = 0;
34706 wxWindow *arg1 = (wxWindow *) 0 ;
34707 void *argp1 = 0 ;
34708 int res1 = 0 ;
34709 PyObject *swig_obj[1] ;
34710
34711 if (!args) SWIG_fail;
34712 swig_obj[0] = args;
34713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34714 if (!SWIG_IsOK(res1)) {
34715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34716 }
34717 arg1 = reinterpret_cast< wxWindow * >(argp1);
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 (arg1)->Fit();
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 resultobj = SWIG_Py_Void();
34725 return resultobj;
34726 fail:
34727 return NULL;
34728 }
34729
34730
34731 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34732 PyObject *resultobj = 0;
34733 wxWindow *arg1 = (wxWindow *) 0 ;
34734 void *argp1 = 0 ;
34735 int res1 = 0 ;
34736 PyObject *swig_obj[1] ;
34737
34738 if (!args) SWIG_fail;
34739 swig_obj[0] = args;
34740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34741 if (!SWIG_IsOK(res1)) {
34742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34743 }
34744 arg1 = reinterpret_cast< wxWindow * >(argp1);
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 (arg1)->FitInside();
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 resultobj = SWIG_Py_Void();
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj = 0;
34760 wxWindow *arg1 = (wxWindow *) 0 ;
34761 int arg2 ;
34762 int arg3 ;
34763 int arg4 = (int) -1 ;
34764 int arg5 = (int) -1 ;
34765 int arg6 = (int) -1 ;
34766 int arg7 = (int) -1 ;
34767 void *argp1 = 0 ;
34768 int res1 = 0 ;
34769 int val2 ;
34770 int ecode2 = 0 ;
34771 int val3 ;
34772 int ecode3 = 0 ;
34773 int val4 ;
34774 int ecode4 = 0 ;
34775 int val5 ;
34776 int ecode5 = 0 ;
34777 int val6 ;
34778 int ecode6 = 0 ;
34779 int val7 ;
34780 int ecode7 = 0 ;
34781 PyObject * obj0 = 0 ;
34782 PyObject * obj1 = 0 ;
34783 PyObject * obj2 = 0 ;
34784 PyObject * obj3 = 0 ;
34785 PyObject * obj4 = 0 ;
34786 PyObject * obj5 = 0 ;
34787 PyObject * obj6 = 0 ;
34788 char * kwnames[] = {
34789 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34790 };
34791
34792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34794 if (!SWIG_IsOK(res1)) {
34795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34796 }
34797 arg1 = reinterpret_cast< wxWindow * >(argp1);
34798 ecode2 = SWIG_AsVal_int(obj1, &val2);
34799 if (!SWIG_IsOK(ecode2)) {
34800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34801 }
34802 arg2 = static_cast< int >(val2);
34803 ecode3 = SWIG_AsVal_int(obj2, &val3);
34804 if (!SWIG_IsOK(ecode3)) {
34805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34806 }
34807 arg3 = static_cast< int >(val3);
34808 if (obj3) {
34809 ecode4 = SWIG_AsVal_int(obj3, &val4);
34810 if (!SWIG_IsOK(ecode4)) {
34811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34812 }
34813 arg4 = static_cast< int >(val4);
34814 }
34815 if (obj4) {
34816 ecode5 = SWIG_AsVal_int(obj4, &val5);
34817 if (!SWIG_IsOK(ecode5)) {
34818 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34819 }
34820 arg5 = static_cast< int >(val5);
34821 }
34822 if (obj5) {
34823 ecode6 = SWIG_AsVal_int(obj5, &val6);
34824 if (!SWIG_IsOK(ecode6)) {
34825 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34826 }
34827 arg6 = static_cast< int >(val6);
34828 }
34829 if (obj6) {
34830 ecode7 = SWIG_AsVal_int(obj6, &val7);
34831 if (!SWIG_IsOK(ecode7)) {
34832 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34833 }
34834 arg7 = static_cast< int >(val7);
34835 }
34836 {
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34839 wxPyEndAllowThreads(__tstate);
34840 if (PyErr_Occurred()) SWIG_fail;
34841 }
34842 resultobj = SWIG_Py_Void();
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34850 PyObject *resultobj = 0;
34851 wxWindow *arg1 = (wxWindow *) 0 ;
34852 wxSize *arg2 = 0 ;
34853 wxSize const &arg3_defvalue = wxDefaultSize ;
34854 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34855 wxSize const &arg4_defvalue = wxDefaultSize ;
34856 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34857 void *argp1 = 0 ;
34858 int res1 = 0 ;
34859 wxSize temp2 ;
34860 wxSize temp3 ;
34861 wxSize temp4 ;
34862 PyObject * obj0 = 0 ;
34863 PyObject * obj1 = 0 ;
34864 PyObject * obj2 = 0 ;
34865 PyObject * obj3 = 0 ;
34866 char * kwnames[] = {
34867 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34868 };
34869
34870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34874 }
34875 arg1 = reinterpret_cast< wxWindow * >(argp1);
34876 {
34877 arg2 = &temp2;
34878 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34879 }
34880 if (obj2) {
34881 {
34882 arg3 = &temp3;
34883 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34884 }
34885 }
34886 if (obj3) {
34887 {
34888 arg4 = &temp4;
34889 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34890 }
34891 }
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34895 wxPyEndAllowThreads(__tstate);
34896 if (PyErr_Occurred()) SWIG_fail;
34897 }
34898 resultobj = SWIG_Py_Void();
34899 return resultobj;
34900 fail:
34901 return NULL;
34902 }
34903
34904
34905 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34906 PyObject *resultobj = 0;
34907 wxWindow *arg1 = (wxWindow *) 0 ;
34908 int arg2 ;
34909 int arg3 ;
34910 int arg4 = (int) -1 ;
34911 int arg5 = (int) -1 ;
34912 void *argp1 = 0 ;
34913 int res1 = 0 ;
34914 int val2 ;
34915 int ecode2 = 0 ;
34916 int val3 ;
34917 int ecode3 = 0 ;
34918 int val4 ;
34919 int ecode4 = 0 ;
34920 int val5 ;
34921 int ecode5 = 0 ;
34922 PyObject * obj0 = 0 ;
34923 PyObject * obj1 = 0 ;
34924 PyObject * obj2 = 0 ;
34925 PyObject * obj3 = 0 ;
34926 PyObject * obj4 = 0 ;
34927 char * kwnames[] = {
34928 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34929 };
34930
34931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34933 if (!SWIG_IsOK(res1)) {
34934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34935 }
34936 arg1 = reinterpret_cast< wxWindow * >(argp1);
34937 ecode2 = SWIG_AsVal_int(obj1, &val2);
34938 if (!SWIG_IsOK(ecode2)) {
34939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34940 }
34941 arg2 = static_cast< int >(val2);
34942 ecode3 = SWIG_AsVal_int(obj2, &val3);
34943 if (!SWIG_IsOK(ecode3)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34945 }
34946 arg3 = static_cast< int >(val3);
34947 if (obj3) {
34948 ecode4 = SWIG_AsVal_int(obj3, &val4);
34949 if (!SWIG_IsOK(ecode4)) {
34950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34951 }
34952 arg4 = static_cast< int >(val4);
34953 }
34954 if (obj4) {
34955 ecode5 = SWIG_AsVal_int(obj4, &val5);
34956 if (!SWIG_IsOK(ecode5)) {
34957 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34958 }
34959 arg5 = static_cast< int >(val5);
34960 }
34961 {
34962 PyThreadState* __tstate = wxPyBeginAllowThreads();
34963 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34964 wxPyEndAllowThreads(__tstate);
34965 if (PyErr_Occurred()) SWIG_fail;
34966 }
34967 resultobj = SWIG_Py_Void();
34968 return resultobj;
34969 fail:
34970 return NULL;
34971 }
34972
34973
34974 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34975 PyObject *resultobj = 0;
34976 wxWindow *arg1 = (wxWindow *) 0 ;
34977 wxSize *arg2 = 0 ;
34978 wxSize const &arg3_defvalue = wxDefaultSize ;
34979 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34980 void *argp1 = 0 ;
34981 int res1 = 0 ;
34982 wxSize temp2 ;
34983 wxSize temp3 ;
34984 PyObject * obj0 = 0 ;
34985 PyObject * obj1 = 0 ;
34986 PyObject * obj2 = 0 ;
34987 char * kwnames[] = {
34988 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34989 };
34990
34991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34993 if (!SWIG_IsOK(res1)) {
34994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34995 }
34996 arg1 = reinterpret_cast< wxWindow * >(argp1);
34997 {
34998 arg2 = &temp2;
34999 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35000 }
35001 if (obj2) {
35002 {
35003 arg3 = &temp3;
35004 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35005 }
35006 }
35007 {
35008 PyThreadState* __tstate = wxPyBeginAllowThreads();
35009 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35010 wxPyEndAllowThreads(__tstate);
35011 if (PyErr_Occurred()) SWIG_fail;
35012 }
35013 resultobj = SWIG_Py_Void();
35014 return resultobj;
35015 fail:
35016 return NULL;
35017 }
35018
35019
35020 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35021 PyObject *resultobj = 0;
35022 wxWindow *arg1 = (wxWindow *) 0 ;
35023 wxSize result;
35024 void *argp1 = 0 ;
35025 int res1 = 0 ;
35026 PyObject *swig_obj[1] ;
35027
35028 if (!args) SWIG_fail;
35029 swig_obj[0] = args;
35030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35031 if (!SWIG_IsOK(res1)) {
35032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35033 }
35034 arg1 = reinterpret_cast< wxWindow * >(argp1);
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 result = ((wxWindow const *)arg1)->GetMaxSize();
35038 wxPyEndAllowThreads(__tstate);
35039 if (PyErr_Occurred()) SWIG_fail;
35040 }
35041 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35049 PyObject *resultobj = 0;
35050 wxWindow *arg1 = (wxWindow *) 0 ;
35051 wxSize result;
35052 void *argp1 = 0 ;
35053 int res1 = 0 ;
35054 PyObject *swig_obj[1] ;
35055
35056 if (!args) SWIG_fail;
35057 swig_obj[0] = args;
35058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35059 if (!SWIG_IsOK(res1)) {
35060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35061 }
35062 arg1 = reinterpret_cast< wxWindow * >(argp1);
35063 {
35064 PyThreadState* __tstate = wxPyBeginAllowThreads();
35065 result = ((wxWindow const *)arg1)->GetMinSize();
35066 wxPyEndAllowThreads(__tstate);
35067 if (PyErr_Occurred()) SWIG_fail;
35068 }
35069 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35070 return resultobj;
35071 fail:
35072 return NULL;
35073 }
35074
35075
35076 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35077 PyObject *resultobj = 0;
35078 wxWindow *arg1 = (wxWindow *) 0 ;
35079 wxSize *arg2 = 0 ;
35080 void *argp1 = 0 ;
35081 int res1 = 0 ;
35082 wxSize temp2 ;
35083 PyObject * obj0 = 0 ;
35084 PyObject * obj1 = 0 ;
35085 char * kwnames[] = {
35086 (char *) "self",(char *) "minSize", NULL
35087 };
35088
35089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35091 if (!SWIG_IsOK(res1)) {
35092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35093 }
35094 arg1 = reinterpret_cast< wxWindow * >(argp1);
35095 {
35096 arg2 = &temp2;
35097 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35098 }
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 (arg1)->SetMinSize((wxSize const &)*arg2);
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 resultobj = SWIG_Py_Void();
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35113 PyObject *resultobj = 0;
35114 wxWindow *arg1 = (wxWindow *) 0 ;
35115 wxSize *arg2 = 0 ;
35116 void *argp1 = 0 ;
35117 int res1 = 0 ;
35118 wxSize temp2 ;
35119 PyObject * obj0 = 0 ;
35120 PyObject * obj1 = 0 ;
35121 char * kwnames[] = {
35122 (char *) "self",(char *) "maxSize", NULL
35123 };
35124
35125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35127 if (!SWIG_IsOK(res1)) {
35128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35129 }
35130 arg1 = reinterpret_cast< wxWindow * >(argp1);
35131 {
35132 arg2 = &temp2;
35133 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35134 }
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 (arg1)->SetMaxSize((wxSize const &)*arg2);
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 resultobj = SWIG_Py_Void();
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35149 PyObject *resultobj = 0;
35150 wxWindow *arg1 = (wxWindow *) 0 ;
35151 int result;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 PyObject *swig_obj[1] ;
35155
35156 if (!args) SWIG_fail;
35157 swig_obj[0] = args;
35158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35159 if (!SWIG_IsOK(res1)) {
35160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35161 }
35162 arg1 = reinterpret_cast< wxWindow * >(argp1);
35163 {
35164 PyThreadState* __tstate = wxPyBeginAllowThreads();
35165 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 resultobj = SWIG_From_int(static_cast< int >(result));
35170 return resultobj;
35171 fail:
35172 return NULL;
35173 }
35174
35175
35176 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35177 PyObject *resultobj = 0;
35178 wxWindow *arg1 = (wxWindow *) 0 ;
35179 int result;
35180 void *argp1 = 0 ;
35181 int res1 = 0 ;
35182 PyObject *swig_obj[1] ;
35183
35184 if (!args) SWIG_fail;
35185 swig_obj[0] = args;
35186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35187 if (!SWIG_IsOK(res1)) {
35188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35189 }
35190 arg1 = reinterpret_cast< wxWindow * >(argp1);
35191 {
35192 PyThreadState* __tstate = wxPyBeginAllowThreads();
35193 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35194 wxPyEndAllowThreads(__tstate);
35195 if (PyErr_Occurred()) SWIG_fail;
35196 }
35197 resultobj = SWIG_From_int(static_cast< int >(result));
35198 return resultobj;
35199 fail:
35200 return NULL;
35201 }
35202
35203
35204 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35205 PyObject *resultobj = 0;
35206 wxWindow *arg1 = (wxWindow *) 0 ;
35207 int result;
35208 void *argp1 = 0 ;
35209 int res1 = 0 ;
35210 PyObject *swig_obj[1] ;
35211
35212 if (!args) SWIG_fail;
35213 swig_obj[0] = args;
35214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35215 if (!SWIG_IsOK(res1)) {
35216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35217 }
35218 arg1 = reinterpret_cast< wxWindow * >(argp1);
35219 {
35220 PyThreadState* __tstate = wxPyBeginAllowThreads();
35221 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35222 wxPyEndAllowThreads(__tstate);
35223 if (PyErr_Occurred()) SWIG_fail;
35224 }
35225 resultobj = SWIG_From_int(static_cast< int >(result));
35226 return resultobj;
35227 fail:
35228 return NULL;
35229 }
35230
35231
35232 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35233 PyObject *resultobj = 0;
35234 wxWindow *arg1 = (wxWindow *) 0 ;
35235 int result;
35236 void *argp1 = 0 ;
35237 int res1 = 0 ;
35238 PyObject *swig_obj[1] ;
35239
35240 if (!args) SWIG_fail;
35241 swig_obj[0] = args;
35242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35245 }
35246 arg1 = reinterpret_cast< wxWindow * >(argp1);
35247 {
35248 PyThreadState* __tstate = wxPyBeginAllowThreads();
35249 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35250 wxPyEndAllowThreads(__tstate);
35251 if (PyErr_Occurred()) SWIG_fail;
35252 }
35253 resultobj = SWIG_From_int(static_cast< int >(result));
35254 return resultobj;
35255 fail:
35256 return NULL;
35257 }
35258
35259
35260 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35261 PyObject *resultobj = 0;
35262 wxWindow *arg1 = (wxWindow *) 0 ;
35263 wxSize *arg2 = 0 ;
35264 void *argp1 = 0 ;
35265 int res1 = 0 ;
35266 wxSize temp2 ;
35267 PyObject * obj0 = 0 ;
35268 PyObject * obj1 = 0 ;
35269 char * kwnames[] = {
35270 (char *) "self",(char *) "size", NULL
35271 };
35272
35273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35275 if (!SWIG_IsOK(res1)) {
35276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35277 }
35278 arg1 = reinterpret_cast< wxWindow * >(argp1);
35279 {
35280 arg2 = &temp2;
35281 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35282 }
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35286 wxPyEndAllowThreads(__tstate);
35287 if (PyErr_Occurred()) SWIG_fail;
35288 }
35289 resultobj = SWIG_Py_Void();
35290 return resultobj;
35291 fail:
35292 return NULL;
35293 }
35294
35295
35296 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj = 0;
35298 wxWindow *arg1 = (wxWindow *) 0 ;
35299 int arg2 ;
35300 int arg3 ;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 int val2 ;
35304 int ecode2 = 0 ;
35305 int val3 ;
35306 int ecode3 = 0 ;
35307 PyObject * obj0 = 0 ;
35308 PyObject * obj1 = 0 ;
35309 PyObject * obj2 = 0 ;
35310 char * kwnames[] = {
35311 (char *) "self",(char *) "w",(char *) "h", NULL
35312 };
35313
35314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35316 if (!SWIG_IsOK(res1)) {
35317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35318 }
35319 arg1 = reinterpret_cast< wxWindow * >(argp1);
35320 ecode2 = SWIG_AsVal_int(obj1, &val2);
35321 if (!SWIG_IsOK(ecode2)) {
35322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35323 }
35324 arg2 = static_cast< int >(val2);
35325 ecode3 = SWIG_AsVal_int(obj2, &val3);
35326 if (!SWIG_IsOK(ecode3)) {
35327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35328 }
35329 arg3 = static_cast< int >(val3);
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 (arg1)->SetVirtualSize(arg2,arg3);
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 resultobj = SWIG_Py_Void();
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35344 PyObject *resultobj = 0;
35345 wxWindow *arg1 = (wxWindow *) 0 ;
35346 wxSize result;
35347 void *argp1 = 0 ;
35348 int res1 = 0 ;
35349 PyObject *swig_obj[1] ;
35350
35351 if (!args) SWIG_fail;
35352 swig_obj[0] = args;
35353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35354 if (!SWIG_IsOK(res1)) {
35355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35356 }
35357 arg1 = reinterpret_cast< wxWindow * >(argp1);
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = ((wxWindow const *)arg1)->GetVirtualSize();
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35372 PyObject *resultobj = 0;
35373 wxWindow *arg1 = (wxWindow *) 0 ;
35374 int *arg2 = (int *) 0 ;
35375 int *arg3 = (int *) 0 ;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 int temp2 ;
35379 int res2 = SWIG_TMPOBJ ;
35380 int temp3 ;
35381 int res3 = SWIG_TMPOBJ ;
35382 PyObject *swig_obj[1] ;
35383
35384 arg2 = &temp2;
35385 arg3 = &temp3;
35386 if (!args) SWIG_fail;
35387 swig_obj[0] = args;
35388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35389 if (!SWIG_IsOK(res1)) {
35390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35391 }
35392 arg1 = reinterpret_cast< wxWindow * >(argp1);
35393 {
35394 PyThreadState* __tstate = wxPyBeginAllowThreads();
35395 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35396 wxPyEndAllowThreads(__tstate);
35397 if (PyErr_Occurred()) SWIG_fail;
35398 }
35399 resultobj = SWIG_Py_Void();
35400 if (SWIG_IsTmpObj(res2)) {
35401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35402 } else {
35403 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35405 }
35406 if (SWIG_IsTmpObj(res3)) {
35407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35408 } else {
35409 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35411 }
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35419 PyObject *resultobj = 0;
35420 wxWindow *arg1 = (wxWindow *) 0 ;
35421 wxSize result;
35422 void *argp1 = 0 ;
35423 int res1 = 0 ;
35424 PyObject *swig_obj[1] ;
35425
35426 if (!args) SWIG_fail;
35427 swig_obj[0] = args;
35428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35431 }
35432 arg1 = reinterpret_cast< wxWindow * >(argp1);
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35436 wxPyEndAllowThreads(__tstate);
35437 if (PyErr_Occurred()) SWIG_fail;
35438 }
35439 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35447 PyObject *resultobj = 0;
35448 wxWindow *arg1 = (wxWindow *) 0 ;
35449 wxSize result;
35450 void *argp1 = 0 ;
35451 int res1 = 0 ;
35452 PyObject *swig_obj[1] ;
35453
35454 if (!args) SWIG_fail;
35455 swig_obj[0] = args;
35456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35457 if (!SWIG_IsOK(res1)) {
35458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35459 }
35460 arg1 = reinterpret_cast< wxWindow * >(argp1);
35461 {
35462 PyThreadState* __tstate = wxPyBeginAllowThreads();
35463 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35464 wxPyEndAllowThreads(__tstate);
35465 if (PyErr_Occurred()) SWIG_fail;
35466 }
35467 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35468 return resultobj;
35469 fail:
35470 return NULL;
35471 }
35472
35473
35474 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35475 PyObject *resultobj = 0;
35476 wxWindow *arg1 = (wxWindow *) 0 ;
35477 bool arg2 = (bool) true ;
35478 bool result;
35479 void *argp1 = 0 ;
35480 int res1 = 0 ;
35481 bool val2 ;
35482 int ecode2 = 0 ;
35483 PyObject * obj0 = 0 ;
35484 PyObject * obj1 = 0 ;
35485 char * kwnames[] = {
35486 (char *) "self",(char *) "show", NULL
35487 };
35488
35489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35491 if (!SWIG_IsOK(res1)) {
35492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35493 }
35494 arg1 = reinterpret_cast< wxWindow * >(argp1);
35495 if (obj1) {
35496 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35497 if (!SWIG_IsOK(ecode2)) {
35498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35499 }
35500 arg2 = static_cast< bool >(val2);
35501 }
35502 {
35503 PyThreadState* __tstate = wxPyBeginAllowThreads();
35504 result = (bool)(arg1)->Show(arg2);
35505 wxPyEndAllowThreads(__tstate);
35506 if (PyErr_Occurred()) SWIG_fail;
35507 }
35508 {
35509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35510 }
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35518 PyObject *resultobj = 0;
35519 wxWindow *arg1 = (wxWindow *) 0 ;
35520 bool result;
35521 void *argp1 = 0 ;
35522 int res1 = 0 ;
35523 PyObject *swig_obj[1] ;
35524
35525 if (!args) SWIG_fail;
35526 swig_obj[0] = args;
35527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35528 if (!SWIG_IsOK(res1)) {
35529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35530 }
35531 arg1 = reinterpret_cast< wxWindow * >(argp1);
35532 {
35533 PyThreadState* __tstate = wxPyBeginAllowThreads();
35534 result = (bool)(arg1)->Hide();
35535 wxPyEndAllowThreads(__tstate);
35536 if (PyErr_Occurred()) SWIG_fail;
35537 }
35538 {
35539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35540 }
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35548 PyObject *resultobj = 0;
35549 wxWindow *arg1 = (wxWindow *) 0 ;
35550 bool arg2 = (bool) true ;
35551 bool result;
35552 void *argp1 = 0 ;
35553 int res1 = 0 ;
35554 bool val2 ;
35555 int ecode2 = 0 ;
35556 PyObject * obj0 = 0 ;
35557 PyObject * obj1 = 0 ;
35558 char * kwnames[] = {
35559 (char *) "self",(char *) "enable", NULL
35560 };
35561
35562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35564 if (!SWIG_IsOK(res1)) {
35565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35566 }
35567 arg1 = reinterpret_cast< wxWindow * >(argp1);
35568 if (obj1) {
35569 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35570 if (!SWIG_IsOK(ecode2)) {
35571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35572 }
35573 arg2 = static_cast< bool >(val2);
35574 }
35575 {
35576 PyThreadState* __tstate = wxPyBeginAllowThreads();
35577 result = (bool)(arg1)->Enable(arg2);
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 {
35582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35583 }
35584 return resultobj;
35585 fail:
35586 return NULL;
35587 }
35588
35589
35590 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35591 PyObject *resultobj = 0;
35592 wxWindow *arg1 = (wxWindow *) 0 ;
35593 bool result;
35594 void *argp1 = 0 ;
35595 int res1 = 0 ;
35596 PyObject *swig_obj[1] ;
35597
35598 if (!args) SWIG_fail;
35599 swig_obj[0] = args;
35600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35601 if (!SWIG_IsOK(res1)) {
35602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35603 }
35604 arg1 = reinterpret_cast< wxWindow * >(argp1);
35605 {
35606 PyThreadState* __tstate = wxPyBeginAllowThreads();
35607 result = (bool)(arg1)->Disable();
35608 wxPyEndAllowThreads(__tstate);
35609 if (PyErr_Occurred()) SWIG_fail;
35610 }
35611 {
35612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35613 }
35614 return resultobj;
35615 fail:
35616 return NULL;
35617 }
35618
35619
35620 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35621 PyObject *resultobj = 0;
35622 wxWindow *arg1 = (wxWindow *) 0 ;
35623 bool result;
35624 void *argp1 = 0 ;
35625 int res1 = 0 ;
35626 PyObject *swig_obj[1] ;
35627
35628 if (!args) SWIG_fail;
35629 swig_obj[0] = args;
35630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35631 if (!SWIG_IsOK(res1)) {
35632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35633 }
35634 arg1 = reinterpret_cast< wxWindow * >(argp1);
35635 {
35636 PyThreadState* __tstate = wxPyBeginAllowThreads();
35637 result = (bool)((wxWindow const *)arg1)->IsShown();
35638 wxPyEndAllowThreads(__tstate);
35639 if (PyErr_Occurred()) SWIG_fail;
35640 }
35641 {
35642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35643 }
35644 return resultobj;
35645 fail:
35646 return NULL;
35647 }
35648
35649
35650 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35651 PyObject *resultobj = 0;
35652 wxWindow *arg1 = (wxWindow *) 0 ;
35653 bool result;
35654 void *argp1 = 0 ;
35655 int res1 = 0 ;
35656 PyObject *swig_obj[1] ;
35657
35658 if (!args) SWIG_fail;
35659 swig_obj[0] = args;
35660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35661 if (!SWIG_IsOK(res1)) {
35662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35663 }
35664 arg1 = reinterpret_cast< wxWindow * >(argp1);
35665 {
35666 PyThreadState* __tstate = wxPyBeginAllowThreads();
35667 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 {
35672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35673 }
35674 return resultobj;
35675 fail:
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35681 PyObject *resultobj = 0;
35682 wxWindow *arg1 = (wxWindow *) 0 ;
35683 bool result;
35684 void *argp1 = 0 ;
35685 int res1 = 0 ;
35686 PyObject *swig_obj[1] ;
35687
35688 if (!args) SWIG_fail;
35689 swig_obj[0] = args;
35690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35691 if (!SWIG_IsOK(res1)) {
35692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35693 }
35694 arg1 = reinterpret_cast< wxWindow * >(argp1);
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 {
35702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35703 }
35704 return resultobj;
35705 fail:
35706 return NULL;
35707 }
35708
35709
35710 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35711 PyObject *resultobj = 0;
35712 wxWindow *arg1 = (wxWindow *) 0 ;
35713 long arg2 ;
35714 void *argp1 = 0 ;
35715 int res1 = 0 ;
35716 long val2 ;
35717 int ecode2 = 0 ;
35718 PyObject * obj0 = 0 ;
35719 PyObject * obj1 = 0 ;
35720 char * kwnames[] = {
35721 (char *) "self",(char *) "style", NULL
35722 };
35723
35724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35726 if (!SWIG_IsOK(res1)) {
35727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35728 }
35729 arg1 = reinterpret_cast< wxWindow * >(argp1);
35730 ecode2 = SWIG_AsVal_long(obj1, &val2);
35731 if (!SWIG_IsOK(ecode2)) {
35732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35733 }
35734 arg2 = static_cast< long >(val2);
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 (arg1)->SetWindowStyleFlag(arg2);
35738 wxPyEndAllowThreads(__tstate);
35739 if (PyErr_Occurred()) SWIG_fail;
35740 }
35741 resultobj = SWIG_Py_Void();
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35749 PyObject *resultobj = 0;
35750 wxWindow *arg1 = (wxWindow *) 0 ;
35751 long result;
35752 void *argp1 = 0 ;
35753 int res1 = 0 ;
35754 PyObject *swig_obj[1] ;
35755
35756 if (!args) SWIG_fail;
35757 swig_obj[0] = args;
35758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35759 if (!SWIG_IsOK(res1)) {
35760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35761 }
35762 arg1 = reinterpret_cast< wxWindow * >(argp1);
35763 {
35764 PyThreadState* __tstate = wxPyBeginAllowThreads();
35765 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 resultobj = SWIG_From_long(static_cast< long >(result));
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35777 PyObject *resultobj = 0;
35778 wxWindow *arg1 = (wxWindow *) 0 ;
35779 int arg2 ;
35780 bool result;
35781 void *argp1 = 0 ;
35782 int res1 = 0 ;
35783 int val2 ;
35784 int ecode2 = 0 ;
35785 PyObject * obj0 = 0 ;
35786 PyObject * obj1 = 0 ;
35787 char * kwnames[] = {
35788 (char *) "self",(char *) "flag", NULL
35789 };
35790
35791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35793 if (!SWIG_IsOK(res1)) {
35794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35795 }
35796 arg1 = reinterpret_cast< wxWindow * >(argp1);
35797 ecode2 = SWIG_AsVal_int(obj1, &val2);
35798 if (!SWIG_IsOK(ecode2)) {
35799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35800 }
35801 arg2 = static_cast< int >(val2);
35802 {
35803 PyThreadState* __tstate = wxPyBeginAllowThreads();
35804 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35805 wxPyEndAllowThreads(__tstate);
35806 if (PyErr_Occurred()) SWIG_fail;
35807 }
35808 {
35809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35810 }
35811 return resultobj;
35812 fail:
35813 return NULL;
35814 }
35815
35816
35817 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35818 PyObject *resultobj = 0;
35819 wxWindow *arg1 = (wxWindow *) 0 ;
35820 bool result;
35821 void *argp1 = 0 ;
35822 int res1 = 0 ;
35823 PyObject *swig_obj[1] ;
35824
35825 if (!args) SWIG_fail;
35826 swig_obj[0] = args;
35827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35828 if (!SWIG_IsOK(res1)) {
35829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35830 }
35831 arg1 = reinterpret_cast< wxWindow * >(argp1);
35832 {
35833 PyThreadState* __tstate = wxPyBeginAllowThreads();
35834 result = (bool)((wxWindow const *)arg1)->IsRetained();
35835 wxPyEndAllowThreads(__tstate);
35836 if (PyErr_Occurred()) SWIG_fail;
35837 }
35838 {
35839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35840 }
35841 return resultobj;
35842 fail:
35843 return NULL;
35844 }
35845
35846
35847 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35848 PyObject *resultobj = 0;
35849 wxWindow *arg1 = (wxWindow *) 0 ;
35850 int arg2 ;
35851 bool result;
35852 void *argp1 = 0 ;
35853 int res1 = 0 ;
35854 int val2 ;
35855 int ecode2 = 0 ;
35856 PyObject * obj0 = 0 ;
35857 PyObject * obj1 = 0 ;
35858 char * kwnames[] = {
35859 (char *) "self",(char *) "flag", NULL
35860 };
35861
35862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35864 if (!SWIG_IsOK(res1)) {
35865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35866 }
35867 arg1 = reinterpret_cast< wxWindow * >(argp1);
35868 ecode2 = SWIG_AsVal_int(obj1, &val2);
35869 if (!SWIG_IsOK(ecode2)) {
35870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
35871 }
35872 arg2 = static_cast< int >(val2);
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = (bool)(arg1)->ToggleWindowStyle(arg2);
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 {
35880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35881 }
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35889 PyObject *resultobj = 0;
35890 wxWindow *arg1 = (wxWindow *) 0 ;
35891 long arg2 ;
35892 void *argp1 = 0 ;
35893 int res1 = 0 ;
35894 long val2 ;
35895 int ecode2 = 0 ;
35896 PyObject * obj0 = 0 ;
35897 PyObject * obj1 = 0 ;
35898 char * kwnames[] = {
35899 (char *) "self",(char *) "exStyle", NULL
35900 };
35901
35902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35904 if (!SWIG_IsOK(res1)) {
35905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35906 }
35907 arg1 = reinterpret_cast< wxWindow * >(argp1);
35908 ecode2 = SWIG_AsVal_long(obj1, &val2);
35909 if (!SWIG_IsOK(ecode2)) {
35910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35911 }
35912 arg2 = static_cast< long >(val2);
35913 {
35914 PyThreadState* __tstate = wxPyBeginAllowThreads();
35915 (arg1)->SetExtraStyle(arg2);
35916 wxPyEndAllowThreads(__tstate);
35917 if (PyErr_Occurred()) SWIG_fail;
35918 }
35919 resultobj = SWIG_Py_Void();
35920 return resultobj;
35921 fail:
35922 return NULL;
35923 }
35924
35925
35926 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35927 PyObject *resultobj = 0;
35928 wxWindow *arg1 = (wxWindow *) 0 ;
35929 long result;
35930 void *argp1 = 0 ;
35931 int res1 = 0 ;
35932 PyObject *swig_obj[1] ;
35933
35934 if (!args) SWIG_fail;
35935 swig_obj[0] = args;
35936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35937 if (!SWIG_IsOK(res1)) {
35938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35939 }
35940 arg1 = reinterpret_cast< wxWindow * >(argp1);
35941 {
35942 PyThreadState* __tstate = wxPyBeginAllowThreads();
35943 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35944 wxPyEndAllowThreads(__tstate);
35945 if (PyErr_Occurred()) SWIG_fail;
35946 }
35947 resultobj = SWIG_From_long(static_cast< long >(result));
35948 return resultobj;
35949 fail:
35950 return NULL;
35951 }
35952
35953
35954 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35955 PyObject *resultobj = 0;
35956 wxWindow *arg1 = (wxWindow *) 0 ;
35957 bool arg2 = (bool) true ;
35958 void *argp1 = 0 ;
35959 int res1 = 0 ;
35960 bool val2 ;
35961 int ecode2 = 0 ;
35962 PyObject * obj0 = 0 ;
35963 PyObject * obj1 = 0 ;
35964 char * kwnames[] = {
35965 (char *) "self",(char *) "modal", NULL
35966 };
35967
35968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35970 if (!SWIG_IsOK(res1)) {
35971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35972 }
35973 arg1 = reinterpret_cast< wxWindow * >(argp1);
35974 if (obj1) {
35975 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35976 if (!SWIG_IsOK(ecode2)) {
35977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35978 }
35979 arg2 = static_cast< bool >(val2);
35980 }
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 (arg1)->MakeModal(arg2);
35984 wxPyEndAllowThreads(__tstate);
35985 if (PyErr_Occurred()) SWIG_fail;
35986 }
35987 resultobj = SWIG_Py_Void();
35988 return resultobj;
35989 fail:
35990 return NULL;
35991 }
35992
35993
35994 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35995 PyObject *resultobj = 0;
35996 wxWindow *arg1 = (wxWindow *) 0 ;
35997 bool arg2 ;
35998 void *argp1 = 0 ;
35999 int res1 = 0 ;
36000 bool val2 ;
36001 int ecode2 = 0 ;
36002 PyObject * obj0 = 0 ;
36003 PyObject * obj1 = 0 ;
36004 char * kwnames[] = {
36005 (char *) "self",(char *) "enableTheme", NULL
36006 };
36007
36008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36010 if (!SWIG_IsOK(res1)) {
36011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36012 }
36013 arg1 = reinterpret_cast< wxWindow * >(argp1);
36014 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36015 if (!SWIG_IsOK(ecode2)) {
36016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36017 }
36018 arg2 = static_cast< bool >(val2);
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 (arg1)->SetThemeEnabled(arg2);
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 resultobj = SWIG_Py_Void();
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36033 PyObject *resultobj = 0;
36034 wxWindow *arg1 = (wxWindow *) 0 ;
36035 bool result;
36036 void *argp1 = 0 ;
36037 int res1 = 0 ;
36038 PyObject *swig_obj[1] ;
36039
36040 if (!args) SWIG_fail;
36041 swig_obj[0] = args;
36042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36043 if (!SWIG_IsOK(res1)) {
36044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36045 }
36046 arg1 = reinterpret_cast< wxWindow * >(argp1);
36047 {
36048 PyThreadState* __tstate = wxPyBeginAllowThreads();
36049 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36050 wxPyEndAllowThreads(__tstate);
36051 if (PyErr_Occurred()) SWIG_fail;
36052 }
36053 {
36054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36055 }
36056 return resultobj;
36057 fail:
36058 return NULL;
36059 }
36060
36061
36062 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36063 PyObject *resultobj = 0;
36064 wxWindow *arg1 = (wxWindow *) 0 ;
36065 void *argp1 = 0 ;
36066 int res1 = 0 ;
36067 PyObject *swig_obj[1] ;
36068
36069 if (!args) SWIG_fail;
36070 swig_obj[0] = args;
36071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36072 if (!SWIG_IsOK(res1)) {
36073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36074 }
36075 arg1 = reinterpret_cast< wxWindow * >(argp1);
36076 {
36077 PyThreadState* __tstate = wxPyBeginAllowThreads();
36078 (arg1)->SetFocus();
36079 wxPyEndAllowThreads(__tstate);
36080 if (PyErr_Occurred()) SWIG_fail;
36081 }
36082 resultobj = SWIG_Py_Void();
36083 return resultobj;
36084 fail:
36085 return NULL;
36086 }
36087
36088
36089 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36090 PyObject *resultobj = 0;
36091 wxWindow *arg1 = (wxWindow *) 0 ;
36092 void *argp1 = 0 ;
36093 int res1 = 0 ;
36094 PyObject *swig_obj[1] ;
36095
36096 if (!args) SWIG_fail;
36097 swig_obj[0] = args;
36098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36099 if (!SWIG_IsOK(res1)) {
36100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36101 }
36102 arg1 = reinterpret_cast< wxWindow * >(argp1);
36103 {
36104 PyThreadState* __tstate = wxPyBeginAllowThreads();
36105 (arg1)->SetFocusFromKbd();
36106 wxPyEndAllowThreads(__tstate);
36107 if (PyErr_Occurred()) SWIG_fail;
36108 }
36109 resultobj = SWIG_Py_Void();
36110 return resultobj;
36111 fail:
36112 return NULL;
36113 }
36114
36115
36116 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36117 PyObject *resultobj = 0;
36118 wxWindow *result = 0 ;
36119
36120 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36121 {
36122 if (!wxPyCheckForApp()) SWIG_fail;
36123 PyThreadState* __tstate = wxPyBeginAllowThreads();
36124 result = (wxWindow *)wxWindow::FindFocus();
36125 wxPyEndAllowThreads(__tstate);
36126 if (PyErr_Occurred()) SWIG_fail;
36127 }
36128 {
36129 resultobj = wxPyMake_wxObject(result, 0);
36130 }
36131 return resultobj;
36132 fail:
36133 return NULL;
36134 }
36135
36136
36137 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36138 PyObject *resultobj = 0;
36139 wxWindow *arg1 = (wxWindow *) 0 ;
36140 bool result;
36141 void *argp1 = 0 ;
36142 int res1 = 0 ;
36143 PyObject *swig_obj[1] ;
36144
36145 if (!args) SWIG_fail;
36146 swig_obj[0] = args;
36147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36148 if (!SWIG_IsOK(res1)) {
36149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36150 }
36151 arg1 = reinterpret_cast< wxWindow * >(argp1);
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 {
36159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36160 }
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36168 PyObject *resultobj = 0;
36169 wxWindow *arg1 = (wxWindow *) 0 ;
36170 bool result;
36171 void *argp1 = 0 ;
36172 int res1 = 0 ;
36173 PyObject *swig_obj[1] ;
36174
36175 if (!args) SWIG_fail;
36176 swig_obj[0] = args;
36177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36178 if (!SWIG_IsOK(res1)) {
36179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36180 }
36181 arg1 = reinterpret_cast< wxWindow * >(argp1);
36182 {
36183 PyThreadState* __tstate = wxPyBeginAllowThreads();
36184 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36185 wxPyEndAllowThreads(__tstate);
36186 if (PyErr_Occurred()) SWIG_fail;
36187 }
36188 {
36189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36190 }
36191 return resultobj;
36192 fail:
36193 return NULL;
36194 }
36195
36196
36197 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36198 PyObject *resultobj = 0;
36199 wxWindow *arg1 = (wxWindow *) 0 ;
36200 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36201 bool result;
36202 void *argp1 = 0 ;
36203 int res1 = 0 ;
36204 int val2 ;
36205 int ecode2 = 0 ;
36206 PyObject * obj0 = 0 ;
36207 PyObject * obj1 = 0 ;
36208 char * kwnames[] = {
36209 (char *) "self",(char *) "flags", NULL
36210 };
36211
36212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36214 if (!SWIG_IsOK(res1)) {
36215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36216 }
36217 arg1 = reinterpret_cast< wxWindow * >(argp1);
36218 if (obj1) {
36219 ecode2 = SWIG_AsVal_int(obj1, &val2);
36220 if (!SWIG_IsOK(ecode2)) {
36221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36222 }
36223 arg2 = static_cast< int >(val2);
36224 }
36225 {
36226 PyThreadState* __tstate = wxPyBeginAllowThreads();
36227 result = (bool)(arg1)->Navigate(arg2);
36228 wxPyEndAllowThreads(__tstate);
36229 if (PyErr_Occurred()) SWIG_fail;
36230 }
36231 {
36232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36233 }
36234 return resultobj;
36235 fail:
36236 return NULL;
36237 }
36238
36239
36240 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36241 PyObject *resultobj = 0;
36242 wxWindow *arg1 = (wxWindow *) 0 ;
36243 wxWindow *arg2 = (wxWindow *) 0 ;
36244 void *argp1 = 0 ;
36245 int res1 = 0 ;
36246 void *argp2 = 0 ;
36247 int res2 = 0 ;
36248 PyObject * obj0 = 0 ;
36249 PyObject * obj1 = 0 ;
36250 char * kwnames[] = {
36251 (char *) "self",(char *) "win", NULL
36252 };
36253
36254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36256 if (!SWIG_IsOK(res1)) {
36257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36258 }
36259 arg1 = reinterpret_cast< wxWindow * >(argp1);
36260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36261 if (!SWIG_IsOK(res2)) {
36262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36263 }
36264 arg2 = reinterpret_cast< wxWindow * >(argp2);
36265 {
36266 PyThreadState* __tstate = wxPyBeginAllowThreads();
36267 (arg1)->MoveAfterInTabOrder(arg2);
36268 wxPyEndAllowThreads(__tstate);
36269 if (PyErr_Occurred()) SWIG_fail;
36270 }
36271 resultobj = SWIG_Py_Void();
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36279 PyObject *resultobj = 0;
36280 wxWindow *arg1 = (wxWindow *) 0 ;
36281 wxWindow *arg2 = (wxWindow *) 0 ;
36282 void *argp1 = 0 ;
36283 int res1 = 0 ;
36284 void *argp2 = 0 ;
36285 int res2 = 0 ;
36286 PyObject * obj0 = 0 ;
36287 PyObject * obj1 = 0 ;
36288 char * kwnames[] = {
36289 (char *) "self",(char *) "win", NULL
36290 };
36291
36292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36294 if (!SWIG_IsOK(res1)) {
36295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36296 }
36297 arg1 = reinterpret_cast< wxWindow * >(argp1);
36298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36299 if (!SWIG_IsOK(res2)) {
36300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36301 }
36302 arg2 = reinterpret_cast< wxWindow * >(argp2);
36303 {
36304 PyThreadState* __tstate = wxPyBeginAllowThreads();
36305 (arg1)->MoveBeforeInTabOrder(arg2);
36306 wxPyEndAllowThreads(__tstate);
36307 if (PyErr_Occurred()) SWIG_fail;
36308 }
36309 resultobj = SWIG_Py_Void();
36310 return resultobj;
36311 fail:
36312 return NULL;
36313 }
36314
36315
36316 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36317 PyObject *resultobj = 0;
36318 wxWindow *arg1 = (wxWindow *) 0 ;
36319 PyObject *result = 0 ;
36320 void *argp1 = 0 ;
36321 int res1 = 0 ;
36322 PyObject *swig_obj[1] ;
36323
36324 if (!args) SWIG_fail;
36325 swig_obj[0] = args;
36326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36327 if (!SWIG_IsOK(res1)) {
36328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36329 }
36330 arg1 = reinterpret_cast< wxWindow * >(argp1);
36331 {
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (PyObject *)wxWindow_GetChildren(arg1);
36334 wxPyEndAllowThreads(__tstate);
36335 if (PyErr_Occurred()) SWIG_fail;
36336 }
36337 resultobj = result;
36338 return resultobj;
36339 fail:
36340 return NULL;
36341 }
36342
36343
36344 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36345 PyObject *resultobj = 0;
36346 wxWindow *arg1 = (wxWindow *) 0 ;
36347 wxWindow *result = 0 ;
36348 void *argp1 = 0 ;
36349 int res1 = 0 ;
36350 PyObject *swig_obj[1] ;
36351
36352 if (!args) SWIG_fail;
36353 swig_obj[0] = args;
36354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36355 if (!SWIG_IsOK(res1)) {
36356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36357 }
36358 arg1 = reinterpret_cast< wxWindow * >(argp1);
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36362 wxPyEndAllowThreads(__tstate);
36363 if (PyErr_Occurred()) SWIG_fail;
36364 }
36365 {
36366 resultobj = wxPyMake_wxObject(result, 0);
36367 }
36368 return resultobj;
36369 fail:
36370 return NULL;
36371 }
36372
36373
36374 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36375 PyObject *resultobj = 0;
36376 wxWindow *arg1 = (wxWindow *) 0 ;
36377 wxWindow *result = 0 ;
36378 void *argp1 = 0 ;
36379 int res1 = 0 ;
36380 PyObject *swig_obj[1] ;
36381
36382 if (!args) SWIG_fail;
36383 swig_obj[0] = args;
36384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36385 if (!SWIG_IsOK(res1)) {
36386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36387 }
36388 arg1 = reinterpret_cast< wxWindow * >(argp1);
36389 {
36390 PyThreadState* __tstate = wxPyBeginAllowThreads();
36391 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36392 wxPyEndAllowThreads(__tstate);
36393 if (PyErr_Occurred()) SWIG_fail;
36394 }
36395 {
36396 resultobj = wxPyMake_wxObject(result, 0);
36397 }
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 bool result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 PyObject *swig_obj[1] ;
36411
36412 if (!args) SWIG_fail;
36413 swig_obj[0] = args;
36414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36415 if (!SWIG_IsOK(res1)) {
36416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36417 }
36418 arg1 = reinterpret_cast< wxWindow * >(argp1);
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 {
36426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36427 }
36428 return resultobj;
36429 fail:
36430 return NULL;
36431 }
36432
36433
36434 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36435 PyObject *resultobj = 0;
36436 wxWindow *arg1 = (wxWindow *) 0 ;
36437 wxWindow *arg2 = (wxWindow *) 0 ;
36438 bool result;
36439 void *argp1 = 0 ;
36440 int res1 = 0 ;
36441 void *argp2 = 0 ;
36442 int res2 = 0 ;
36443 PyObject * obj0 = 0 ;
36444 PyObject * obj1 = 0 ;
36445 char * kwnames[] = {
36446 (char *) "self",(char *) "newParent", NULL
36447 };
36448
36449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36451 if (!SWIG_IsOK(res1)) {
36452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36453 }
36454 arg1 = reinterpret_cast< wxWindow * >(argp1);
36455 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36456 if (!SWIG_IsOK(res2)) {
36457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36458 }
36459 arg2 = reinterpret_cast< wxWindow * >(argp2);
36460 {
36461 PyThreadState* __tstate = wxPyBeginAllowThreads();
36462 result = (bool)(arg1)->Reparent(arg2);
36463 wxPyEndAllowThreads(__tstate);
36464 if (PyErr_Occurred()) SWIG_fail;
36465 }
36466 {
36467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36468 }
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj = 0;
36477 wxWindow *arg1 = (wxWindow *) 0 ;
36478 wxWindow *arg2 = (wxWindow *) 0 ;
36479 void *argp1 = 0 ;
36480 int res1 = 0 ;
36481 void *argp2 = 0 ;
36482 int res2 = 0 ;
36483 PyObject * obj0 = 0 ;
36484 PyObject * obj1 = 0 ;
36485 char * kwnames[] = {
36486 (char *) "self",(char *) "child", NULL
36487 };
36488
36489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36491 if (!SWIG_IsOK(res1)) {
36492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36493 }
36494 arg1 = reinterpret_cast< wxWindow * >(argp1);
36495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36496 if (!SWIG_IsOK(res2)) {
36497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36498 }
36499 arg2 = reinterpret_cast< wxWindow * >(argp2);
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 (arg1)->AddChild(arg2);
36503 wxPyEndAllowThreads(__tstate);
36504 if (PyErr_Occurred()) SWIG_fail;
36505 }
36506 resultobj = SWIG_Py_Void();
36507 return resultobj;
36508 fail:
36509 return NULL;
36510 }
36511
36512
36513 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36514 PyObject *resultobj = 0;
36515 wxWindow *arg1 = (wxWindow *) 0 ;
36516 wxWindow *arg2 = (wxWindow *) 0 ;
36517 void *argp1 = 0 ;
36518 int res1 = 0 ;
36519 void *argp2 = 0 ;
36520 int res2 = 0 ;
36521 PyObject * obj0 = 0 ;
36522 PyObject * obj1 = 0 ;
36523 char * kwnames[] = {
36524 (char *) "self",(char *) "child", NULL
36525 };
36526
36527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36529 if (!SWIG_IsOK(res1)) {
36530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36531 }
36532 arg1 = reinterpret_cast< wxWindow * >(argp1);
36533 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36534 if (!SWIG_IsOK(res2)) {
36535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36536 }
36537 arg2 = reinterpret_cast< wxWindow * >(argp2);
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 (arg1)->RemoveChild(arg2);
36541 wxPyEndAllowThreads(__tstate);
36542 if (PyErr_Occurred()) SWIG_fail;
36543 }
36544 resultobj = SWIG_Py_Void();
36545 return resultobj;
36546 fail:
36547 return NULL;
36548 }
36549
36550
36551 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36552 PyObject *resultobj = 0;
36553 wxWindow *arg1 = (wxWindow *) 0 ;
36554 bool arg2 ;
36555 void *argp1 = 0 ;
36556 int res1 = 0 ;
36557 bool val2 ;
36558 int ecode2 = 0 ;
36559 PyObject * obj0 = 0 ;
36560 PyObject * obj1 = 0 ;
36561 char * kwnames[] = {
36562 (char *) "self",(char *) "on", NULL
36563 };
36564
36565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36567 if (!SWIG_IsOK(res1)) {
36568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36569 }
36570 arg1 = reinterpret_cast< wxWindow * >(argp1);
36571 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36572 if (!SWIG_IsOK(ecode2)) {
36573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36574 }
36575 arg2 = static_cast< bool >(val2);
36576 {
36577 PyThreadState* __tstate = wxPyBeginAllowThreads();
36578 (arg1)->SetDoubleBuffered(arg2);
36579 wxPyEndAllowThreads(__tstate);
36580 if (PyErr_Occurred()) SWIG_fail;
36581 }
36582 resultobj = SWIG_Py_Void();
36583 return resultobj;
36584 fail:
36585 return NULL;
36586 }
36587
36588
36589 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36590 PyObject *resultobj = 0;
36591 wxWindow *arg1 = (wxWindow *) 0 ;
36592 long arg2 ;
36593 wxWindow *result = 0 ;
36594 void *argp1 = 0 ;
36595 int res1 = 0 ;
36596 long val2 ;
36597 int ecode2 = 0 ;
36598 PyObject * obj0 = 0 ;
36599 PyObject * obj1 = 0 ;
36600 char * kwnames[] = {
36601 (char *) "self",(char *) "winid", NULL
36602 };
36603
36604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36608 }
36609 arg1 = reinterpret_cast< wxWindow * >(argp1);
36610 ecode2 = SWIG_AsVal_long(obj1, &val2);
36611 if (!SWIG_IsOK(ecode2)) {
36612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36613 }
36614 arg2 = static_cast< long >(val2);
36615 {
36616 PyThreadState* __tstate = wxPyBeginAllowThreads();
36617 result = (wxWindow *)(arg1)->FindWindow(arg2);
36618 wxPyEndAllowThreads(__tstate);
36619 if (PyErr_Occurred()) SWIG_fail;
36620 }
36621 {
36622 resultobj = wxPyMake_wxObject(result, 0);
36623 }
36624 return resultobj;
36625 fail:
36626 return NULL;
36627 }
36628
36629
36630 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36631 PyObject *resultobj = 0;
36632 wxWindow *arg1 = (wxWindow *) 0 ;
36633 wxString *arg2 = 0 ;
36634 wxWindow *result = 0 ;
36635 void *argp1 = 0 ;
36636 int res1 = 0 ;
36637 bool temp2 = false ;
36638 PyObject * obj0 = 0 ;
36639 PyObject * obj1 = 0 ;
36640 char * kwnames[] = {
36641 (char *) "self",(char *) "name", NULL
36642 };
36643
36644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36646 if (!SWIG_IsOK(res1)) {
36647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36648 }
36649 arg1 = reinterpret_cast< wxWindow * >(argp1);
36650 {
36651 arg2 = wxString_in_helper(obj1);
36652 if (arg2 == NULL) SWIG_fail;
36653 temp2 = true;
36654 }
36655 {
36656 PyThreadState* __tstate = wxPyBeginAllowThreads();
36657 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36658 wxPyEndAllowThreads(__tstate);
36659 if (PyErr_Occurred()) SWIG_fail;
36660 }
36661 {
36662 resultobj = wxPyMake_wxObject(result, 0);
36663 }
36664 {
36665 if (temp2)
36666 delete arg2;
36667 }
36668 return resultobj;
36669 fail:
36670 {
36671 if (temp2)
36672 delete arg2;
36673 }
36674 return NULL;
36675 }
36676
36677
36678 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36679 PyObject *resultobj = 0;
36680 wxWindow *arg1 = (wxWindow *) 0 ;
36681 wxEvtHandler *result = 0 ;
36682 void *argp1 = 0 ;
36683 int res1 = 0 ;
36684 PyObject *swig_obj[1] ;
36685
36686 if (!args) SWIG_fail;
36687 swig_obj[0] = args;
36688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36689 if (!SWIG_IsOK(res1)) {
36690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36691 }
36692 arg1 = reinterpret_cast< wxWindow * >(argp1);
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36696 wxPyEndAllowThreads(__tstate);
36697 if (PyErr_Occurred()) SWIG_fail;
36698 }
36699 {
36700 resultobj = wxPyMake_wxObject(result, 0);
36701 }
36702 return resultobj;
36703 fail:
36704 return NULL;
36705 }
36706
36707
36708 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36709 PyObject *resultobj = 0;
36710 wxWindow *arg1 = (wxWindow *) 0 ;
36711 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36712 void *argp1 = 0 ;
36713 int res1 = 0 ;
36714 void *argp2 = 0 ;
36715 int res2 = 0 ;
36716 PyObject * obj0 = 0 ;
36717 PyObject * obj1 = 0 ;
36718 char * kwnames[] = {
36719 (char *) "self",(char *) "handler", NULL
36720 };
36721
36722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36724 if (!SWIG_IsOK(res1)) {
36725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36726 }
36727 arg1 = reinterpret_cast< wxWindow * >(argp1);
36728 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36729 if (!SWIG_IsOK(res2)) {
36730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36731 }
36732 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36733 {
36734 PyThreadState* __tstate = wxPyBeginAllowThreads();
36735 (arg1)->SetEventHandler(arg2);
36736 wxPyEndAllowThreads(__tstate);
36737 if (PyErr_Occurred()) SWIG_fail;
36738 }
36739 resultobj = SWIG_Py_Void();
36740 return resultobj;
36741 fail:
36742 return NULL;
36743 }
36744
36745
36746 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36747 PyObject *resultobj = 0;
36748 wxWindow *arg1 = (wxWindow *) 0 ;
36749 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 void *argp2 = 0 ;
36753 int res2 = 0 ;
36754 PyObject * obj0 = 0 ;
36755 PyObject * obj1 = 0 ;
36756 char * kwnames[] = {
36757 (char *) "self",(char *) "handler", NULL
36758 };
36759
36760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36764 }
36765 arg1 = reinterpret_cast< wxWindow * >(argp1);
36766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36767 if (!SWIG_IsOK(res2)) {
36768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36769 }
36770 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 (arg1)->PushEventHandler(arg2);
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 resultobj = SWIG_Py_Void();
36778 return resultobj;
36779 fail:
36780 return NULL;
36781 }
36782
36783
36784 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36785 PyObject *resultobj = 0;
36786 wxWindow *arg1 = (wxWindow *) 0 ;
36787 bool arg2 = (bool) false ;
36788 wxEvtHandler *result = 0 ;
36789 void *argp1 = 0 ;
36790 int res1 = 0 ;
36791 bool val2 ;
36792 int ecode2 = 0 ;
36793 PyObject * obj0 = 0 ;
36794 PyObject * obj1 = 0 ;
36795 char * kwnames[] = {
36796 (char *) "self",(char *) "deleteHandler", NULL
36797 };
36798
36799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36801 if (!SWIG_IsOK(res1)) {
36802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36803 }
36804 arg1 = reinterpret_cast< wxWindow * >(argp1);
36805 if (obj1) {
36806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36807 if (!SWIG_IsOK(ecode2)) {
36808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36809 }
36810 arg2 = static_cast< bool >(val2);
36811 }
36812 {
36813 PyThreadState* __tstate = wxPyBeginAllowThreads();
36814 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36815 wxPyEndAllowThreads(__tstate);
36816 if (PyErr_Occurred()) SWIG_fail;
36817 }
36818 {
36819 resultobj = wxPyMake_wxObject(result, 0);
36820 }
36821 return resultobj;
36822 fail:
36823 return NULL;
36824 }
36825
36826
36827 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36828 PyObject *resultobj = 0;
36829 wxWindow *arg1 = (wxWindow *) 0 ;
36830 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36831 bool result;
36832 void *argp1 = 0 ;
36833 int res1 = 0 ;
36834 void *argp2 = 0 ;
36835 int res2 = 0 ;
36836 PyObject * obj0 = 0 ;
36837 PyObject * obj1 = 0 ;
36838 char * kwnames[] = {
36839 (char *) "self",(char *) "handler", NULL
36840 };
36841
36842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36844 if (!SWIG_IsOK(res1)) {
36845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36846 }
36847 arg1 = reinterpret_cast< wxWindow * >(argp1);
36848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36849 if (!SWIG_IsOK(res2)) {
36850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36851 }
36852 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36853 {
36854 PyThreadState* __tstate = wxPyBeginAllowThreads();
36855 result = (bool)(arg1)->RemoveEventHandler(arg2);
36856 wxPyEndAllowThreads(__tstate);
36857 if (PyErr_Occurred()) SWIG_fail;
36858 }
36859 {
36860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36861 }
36862 return resultobj;
36863 fail:
36864 return NULL;
36865 }
36866
36867
36868 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36869 PyObject *resultobj = 0;
36870 wxWindow *arg1 = (wxWindow *) 0 ;
36871 wxValidator *arg2 = 0 ;
36872 void *argp1 = 0 ;
36873 int res1 = 0 ;
36874 void *argp2 = 0 ;
36875 int res2 = 0 ;
36876 PyObject * obj0 = 0 ;
36877 PyObject * obj1 = 0 ;
36878 char * kwnames[] = {
36879 (char *) "self",(char *) "validator", NULL
36880 };
36881
36882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36884 if (!SWIG_IsOK(res1)) {
36885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36886 }
36887 arg1 = reinterpret_cast< wxWindow * >(argp1);
36888 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36889 if (!SWIG_IsOK(res2)) {
36890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36891 }
36892 if (!argp2) {
36893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36894 }
36895 arg2 = reinterpret_cast< wxValidator * >(argp2);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 (arg1)->SetValidator((wxValidator const &)*arg2);
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 resultobj = SWIG_Py_Void();
36903 return resultobj;
36904 fail:
36905 return NULL;
36906 }
36907
36908
36909 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36910 PyObject *resultobj = 0;
36911 wxWindow *arg1 = (wxWindow *) 0 ;
36912 wxValidator *result = 0 ;
36913 void *argp1 = 0 ;
36914 int res1 = 0 ;
36915 PyObject *swig_obj[1] ;
36916
36917 if (!args) SWIG_fail;
36918 swig_obj[0] = args;
36919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36920 if (!SWIG_IsOK(res1)) {
36921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36922 }
36923 arg1 = reinterpret_cast< wxWindow * >(argp1);
36924 {
36925 PyThreadState* __tstate = wxPyBeginAllowThreads();
36926 result = (wxValidator *)(arg1)->GetValidator();
36927 wxPyEndAllowThreads(__tstate);
36928 if (PyErr_Occurred()) SWIG_fail;
36929 }
36930 {
36931 resultobj = wxPyMake_wxObject(result, (bool)0);
36932 }
36933 return resultobj;
36934 fail:
36935 return NULL;
36936 }
36937
36938
36939 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36940 PyObject *resultobj = 0;
36941 wxWindow *arg1 = (wxWindow *) 0 ;
36942 bool result;
36943 void *argp1 = 0 ;
36944 int res1 = 0 ;
36945 PyObject *swig_obj[1] ;
36946
36947 if (!args) SWIG_fail;
36948 swig_obj[0] = args;
36949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36950 if (!SWIG_IsOK(res1)) {
36951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36952 }
36953 arg1 = reinterpret_cast< wxWindow * >(argp1);
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = (bool)(arg1)->Validate();
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 {
36961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36962 }
36963 return resultobj;
36964 fail:
36965 return NULL;
36966 }
36967
36968
36969 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36970 PyObject *resultobj = 0;
36971 wxWindow *arg1 = (wxWindow *) 0 ;
36972 bool result;
36973 void *argp1 = 0 ;
36974 int res1 = 0 ;
36975 PyObject *swig_obj[1] ;
36976
36977 if (!args) SWIG_fail;
36978 swig_obj[0] = args;
36979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36980 if (!SWIG_IsOK(res1)) {
36981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36982 }
36983 arg1 = reinterpret_cast< wxWindow * >(argp1);
36984 {
36985 PyThreadState* __tstate = wxPyBeginAllowThreads();
36986 result = (bool)(arg1)->TransferDataToWindow();
36987 wxPyEndAllowThreads(__tstate);
36988 if (PyErr_Occurred()) SWIG_fail;
36989 }
36990 {
36991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36992 }
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37000 PyObject *resultobj = 0;
37001 wxWindow *arg1 = (wxWindow *) 0 ;
37002 bool result;
37003 void *argp1 = 0 ;
37004 int res1 = 0 ;
37005 PyObject *swig_obj[1] ;
37006
37007 if (!args) SWIG_fail;
37008 swig_obj[0] = args;
37009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37010 if (!SWIG_IsOK(res1)) {
37011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37012 }
37013 arg1 = reinterpret_cast< wxWindow * >(argp1);
37014 {
37015 PyThreadState* __tstate = wxPyBeginAllowThreads();
37016 result = (bool)(arg1)->TransferDataFromWindow();
37017 wxPyEndAllowThreads(__tstate);
37018 if (PyErr_Occurred()) SWIG_fail;
37019 }
37020 {
37021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37022 }
37023 return resultobj;
37024 fail:
37025 return NULL;
37026 }
37027
37028
37029 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37030 PyObject *resultobj = 0;
37031 wxWindow *arg1 = (wxWindow *) 0 ;
37032 void *argp1 = 0 ;
37033 int res1 = 0 ;
37034 PyObject *swig_obj[1] ;
37035
37036 if (!args) SWIG_fail;
37037 swig_obj[0] = args;
37038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37039 if (!SWIG_IsOK(res1)) {
37040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37041 }
37042 arg1 = reinterpret_cast< wxWindow * >(argp1);
37043 {
37044 PyThreadState* __tstate = wxPyBeginAllowThreads();
37045 (arg1)->InitDialog();
37046 wxPyEndAllowThreads(__tstate);
37047 if (PyErr_Occurred()) SWIG_fail;
37048 }
37049 resultobj = SWIG_Py_Void();
37050 return resultobj;
37051 fail:
37052 return NULL;
37053 }
37054
37055
37056 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37057 PyObject *resultobj = 0;
37058 wxWindow *arg1 = (wxWindow *) 0 ;
37059 wxAcceleratorTable *arg2 = 0 ;
37060 void *argp1 = 0 ;
37061 int res1 = 0 ;
37062 void *argp2 = 0 ;
37063 int res2 = 0 ;
37064 PyObject * obj0 = 0 ;
37065 PyObject * obj1 = 0 ;
37066 char * kwnames[] = {
37067 (char *) "self",(char *) "accel", NULL
37068 };
37069
37070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37072 if (!SWIG_IsOK(res1)) {
37073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37074 }
37075 arg1 = reinterpret_cast< wxWindow * >(argp1);
37076 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37077 if (!SWIG_IsOK(res2)) {
37078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37079 }
37080 if (!argp2) {
37081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37082 }
37083 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37084 {
37085 PyThreadState* __tstate = wxPyBeginAllowThreads();
37086 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37087 wxPyEndAllowThreads(__tstate);
37088 if (PyErr_Occurred()) SWIG_fail;
37089 }
37090 resultobj = SWIG_Py_Void();
37091 return resultobj;
37092 fail:
37093 return NULL;
37094 }
37095
37096
37097 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37098 PyObject *resultobj = 0;
37099 wxWindow *arg1 = (wxWindow *) 0 ;
37100 wxAcceleratorTable *result = 0 ;
37101 void *argp1 = 0 ;
37102 int res1 = 0 ;
37103 PyObject *swig_obj[1] ;
37104
37105 if (!args) SWIG_fail;
37106 swig_obj[0] = args;
37107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37108 if (!SWIG_IsOK(res1)) {
37109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37110 }
37111 arg1 = reinterpret_cast< wxWindow * >(argp1);
37112 {
37113 PyThreadState* __tstate = wxPyBeginAllowThreads();
37114 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37115 wxPyEndAllowThreads(__tstate);
37116 if (PyErr_Occurred()) SWIG_fail;
37117 }
37118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37119 return resultobj;
37120 fail:
37121 return NULL;
37122 }
37123
37124
37125 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37126 PyObject *resultobj = 0;
37127 wxWindow *arg1 = (wxWindow *) 0 ;
37128 int arg2 ;
37129 int arg3 ;
37130 int arg4 ;
37131 bool result;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 int val2 ;
37135 int ecode2 = 0 ;
37136 int val3 ;
37137 int ecode3 = 0 ;
37138 int val4 ;
37139 int ecode4 = 0 ;
37140 PyObject * obj0 = 0 ;
37141 PyObject * obj1 = 0 ;
37142 PyObject * obj2 = 0 ;
37143 PyObject * obj3 = 0 ;
37144 char * kwnames[] = {
37145 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37146 };
37147
37148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37150 if (!SWIG_IsOK(res1)) {
37151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37152 }
37153 arg1 = reinterpret_cast< wxWindow * >(argp1);
37154 ecode2 = SWIG_AsVal_int(obj1, &val2);
37155 if (!SWIG_IsOK(ecode2)) {
37156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37157 }
37158 arg2 = static_cast< int >(val2);
37159 ecode3 = SWIG_AsVal_int(obj2, &val3);
37160 if (!SWIG_IsOK(ecode3)) {
37161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37162 }
37163 arg3 = static_cast< int >(val3);
37164 ecode4 = SWIG_AsVal_int(obj3, &val4);
37165 if (!SWIG_IsOK(ecode4)) {
37166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37167 }
37168 arg4 = static_cast< int >(val4);
37169 {
37170 PyThreadState* __tstate = wxPyBeginAllowThreads();
37171 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37172 wxPyEndAllowThreads(__tstate);
37173 if (PyErr_Occurred()) SWIG_fail;
37174 }
37175 {
37176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37177 }
37178 return resultobj;
37179 fail:
37180 return NULL;
37181 }
37182
37183
37184 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37185 PyObject *resultobj = 0;
37186 wxWindow *arg1 = (wxWindow *) 0 ;
37187 int arg2 ;
37188 bool result;
37189 void *argp1 = 0 ;
37190 int res1 = 0 ;
37191 int val2 ;
37192 int ecode2 = 0 ;
37193 PyObject * obj0 = 0 ;
37194 PyObject * obj1 = 0 ;
37195 char * kwnames[] = {
37196 (char *) "self",(char *) "hotkeyId", NULL
37197 };
37198
37199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37201 if (!SWIG_IsOK(res1)) {
37202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37203 }
37204 arg1 = reinterpret_cast< wxWindow * >(argp1);
37205 ecode2 = SWIG_AsVal_int(obj1, &val2);
37206 if (!SWIG_IsOK(ecode2)) {
37207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37208 }
37209 arg2 = static_cast< int >(val2);
37210 {
37211 PyThreadState* __tstate = wxPyBeginAllowThreads();
37212 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37213 wxPyEndAllowThreads(__tstate);
37214 if (PyErr_Occurred()) SWIG_fail;
37215 }
37216 {
37217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37218 }
37219 return resultobj;
37220 fail:
37221 return NULL;
37222 }
37223
37224
37225 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37226 PyObject *resultobj = 0;
37227 wxWindow *arg1 = (wxWindow *) 0 ;
37228 wxPoint *arg2 = 0 ;
37229 wxPoint result;
37230 void *argp1 = 0 ;
37231 int res1 = 0 ;
37232 wxPoint temp2 ;
37233 PyObject * obj0 = 0 ;
37234 PyObject * obj1 = 0 ;
37235 char * kwnames[] = {
37236 (char *) "self",(char *) "pt", NULL
37237 };
37238
37239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37241 if (!SWIG_IsOK(res1)) {
37242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37243 }
37244 arg1 = reinterpret_cast< wxWindow * >(argp1);
37245 {
37246 arg2 = &temp2;
37247 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37248 }
37249 {
37250 PyThreadState* __tstate = wxPyBeginAllowThreads();
37251 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37252 wxPyEndAllowThreads(__tstate);
37253 if (PyErr_Occurred()) SWIG_fail;
37254 }
37255 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37256 return resultobj;
37257 fail:
37258 return NULL;
37259 }
37260
37261
37262 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37263 PyObject *resultobj = 0;
37264 wxWindow *arg1 = (wxWindow *) 0 ;
37265 wxSize *arg2 = 0 ;
37266 wxSize result;
37267 void *argp1 = 0 ;
37268 int res1 = 0 ;
37269 wxSize temp2 ;
37270 PyObject * obj0 = 0 ;
37271 PyObject * obj1 = 0 ;
37272 char * kwnames[] = {
37273 (char *) "self",(char *) "sz", NULL
37274 };
37275
37276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37278 if (!SWIG_IsOK(res1)) {
37279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37280 }
37281 arg1 = reinterpret_cast< wxWindow * >(argp1);
37282 {
37283 arg2 = &temp2;
37284 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37285 }
37286 {
37287 PyThreadState* __tstate = wxPyBeginAllowThreads();
37288 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37293 return resultobj;
37294 fail:
37295 return NULL;
37296 }
37297
37298
37299 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37300 PyObject *resultobj = 0;
37301 wxWindow *arg1 = (wxWindow *) 0 ;
37302 wxPoint *arg2 = 0 ;
37303 wxPoint result;
37304 void *argp1 = 0 ;
37305 int res1 = 0 ;
37306 wxPoint temp2 ;
37307 PyObject * obj0 = 0 ;
37308 PyObject * obj1 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "pt", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 {
37320 arg2 = &temp2;
37321 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37322 }
37323 {
37324 PyThreadState* __tstate = wxPyBeginAllowThreads();
37325 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37326 wxPyEndAllowThreads(__tstate);
37327 if (PyErr_Occurred()) SWIG_fail;
37328 }
37329 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37330 return resultobj;
37331 fail:
37332 return NULL;
37333 }
37334
37335
37336 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37337 PyObject *resultobj = 0;
37338 wxWindow *arg1 = (wxWindow *) 0 ;
37339 wxSize *arg2 = 0 ;
37340 wxSize result;
37341 void *argp1 = 0 ;
37342 int res1 = 0 ;
37343 wxSize temp2 ;
37344 PyObject * obj0 = 0 ;
37345 PyObject * obj1 = 0 ;
37346 char * kwnames[] = {
37347 (char *) "self",(char *) "sz", NULL
37348 };
37349
37350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37352 if (!SWIG_IsOK(res1)) {
37353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37354 }
37355 arg1 = reinterpret_cast< wxWindow * >(argp1);
37356 {
37357 arg2 = &temp2;
37358 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37359 }
37360 {
37361 PyThreadState* __tstate = wxPyBeginAllowThreads();
37362 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37363 wxPyEndAllowThreads(__tstate);
37364 if (PyErr_Occurred()) SWIG_fail;
37365 }
37366 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37367 return resultobj;
37368 fail:
37369 return NULL;
37370 }
37371
37372
37373 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37374 PyObject *resultobj = 0;
37375 wxWindow *arg1 = (wxWindow *) 0 ;
37376 wxPoint *arg2 = 0 ;
37377 wxPoint result;
37378 void *argp1 = 0 ;
37379 int res1 = 0 ;
37380 wxPoint temp2 ;
37381 PyObject * obj0 = 0 ;
37382 PyObject * obj1 = 0 ;
37383 char * kwnames[] = {
37384 (char *) "self",(char *) "pt", NULL
37385 };
37386
37387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37389 if (!SWIG_IsOK(res1)) {
37390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37391 }
37392 arg1 = reinterpret_cast< wxWindow * >(argp1);
37393 {
37394 arg2 = &temp2;
37395 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37396 }
37397 {
37398 PyThreadState* __tstate = wxPyBeginAllowThreads();
37399 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37400 wxPyEndAllowThreads(__tstate);
37401 if (PyErr_Occurred()) SWIG_fail;
37402 }
37403 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37404 return resultobj;
37405 fail:
37406 return NULL;
37407 }
37408
37409
37410 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37411 PyObject *resultobj = 0;
37412 wxWindow *arg1 = (wxWindow *) 0 ;
37413 wxSize *arg2 = 0 ;
37414 wxSize result;
37415 void *argp1 = 0 ;
37416 int res1 = 0 ;
37417 wxSize temp2 ;
37418 PyObject * obj0 = 0 ;
37419 PyObject * obj1 = 0 ;
37420 char * kwnames[] = {
37421 (char *) "self",(char *) "sz", NULL
37422 };
37423
37424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37426 if (!SWIG_IsOK(res1)) {
37427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37428 }
37429 arg1 = reinterpret_cast< wxWindow * >(argp1);
37430 {
37431 arg2 = &temp2;
37432 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37433 }
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37448 PyObject *resultobj = 0;
37449 wxWindow *arg1 = (wxWindow *) 0 ;
37450 int arg2 ;
37451 int arg3 ;
37452 void *argp1 = 0 ;
37453 int res1 = 0 ;
37454 int val2 ;
37455 int ecode2 = 0 ;
37456 int val3 ;
37457 int ecode3 = 0 ;
37458 PyObject * obj0 = 0 ;
37459 PyObject * obj1 = 0 ;
37460 PyObject * obj2 = 0 ;
37461 char * kwnames[] = {
37462 (char *) "self",(char *) "x",(char *) "y", NULL
37463 };
37464
37465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37467 if (!SWIG_IsOK(res1)) {
37468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37469 }
37470 arg1 = reinterpret_cast< wxWindow * >(argp1);
37471 ecode2 = SWIG_AsVal_int(obj1, &val2);
37472 if (!SWIG_IsOK(ecode2)) {
37473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37474 }
37475 arg2 = static_cast< int >(val2);
37476 ecode3 = SWIG_AsVal_int(obj2, &val3);
37477 if (!SWIG_IsOK(ecode3)) {
37478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37479 }
37480 arg3 = static_cast< int >(val3);
37481 {
37482 PyThreadState* __tstate = wxPyBeginAllowThreads();
37483 (arg1)->WarpPointer(arg2,arg3);
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 resultobj = SWIG_Py_Void();
37488 return resultobj;
37489 fail:
37490 return NULL;
37491 }
37492
37493
37494 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37495 PyObject *resultobj = 0;
37496 wxWindow *arg1 = (wxWindow *) 0 ;
37497 void *argp1 = 0 ;
37498 int res1 = 0 ;
37499 PyObject *swig_obj[1] ;
37500
37501 if (!args) SWIG_fail;
37502 swig_obj[0] = args;
37503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37504 if (!SWIG_IsOK(res1)) {
37505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37506 }
37507 arg1 = reinterpret_cast< wxWindow * >(argp1);
37508 {
37509 PyThreadState* __tstate = wxPyBeginAllowThreads();
37510 (arg1)->CaptureMouse();
37511 wxPyEndAllowThreads(__tstate);
37512 if (PyErr_Occurred()) SWIG_fail;
37513 }
37514 resultobj = SWIG_Py_Void();
37515 return resultobj;
37516 fail:
37517 return NULL;
37518 }
37519
37520
37521 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37522 PyObject *resultobj = 0;
37523 wxWindow *arg1 = (wxWindow *) 0 ;
37524 void *argp1 = 0 ;
37525 int res1 = 0 ;
37526 PyObject *swig_obj[1] ;
37527
37528 if (!args) SWIG_fail;
37529 swig_obj[0] = args;
37530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37531 if (!SWIG_IsOK(res1)) {
37532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37533 }
37534 arg1 = reinterpret_cast< wxWindow * >(argp1);
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 (arg1)->ReleaseMouse();
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 resultobj = SWIG_Py_Void();
37542 return resultobj;
37543 fail:
37544 return NULL;
37545 }
37546
37547
37548 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37549 PyObject *resultobj = 0;
37550 wxWindow *result = 0 ;
37551
37552 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37553 {
37554 if (!wxPyCheckForApp()) SWIG_fail;
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 result = (wxWindow *)wxWindow::GetCapture();
37557 wxPyEndAllowThreads(__tstate);
37558 if (PyErr_Occurred()) SWIG_fail;
37559 }
37560 {
37561 resultobj = wxPyMake_wxObject(result, 0);
37562 }
37563 return resultobj;
37564 fail:
37565 return NULL;
37566 }
37567
37568
37569 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37570 PyObject *resultobj = 0;
37571 wxWindow *arg1 = (wxWindow *) 0 ;
37572 bool result;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 PyObject *swig_obj[1] ;
37576
37577 if (!args) SWIG_fail;
37578 swig_obj[0] = args;
37579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37580 if (!SWIG_IsOK(res1)) {
37581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37582 }
37583 arg1 = reinterpret_cast< wxWindow * >(argp1);
37584 {
37585 PyThreadState* __tstate = wxPyBeginAllowThreads();
37586 result = (bool)((wxWindow const *)arg1)->HasCapture();
37587 wxPyEndAllowThreads(__tstate);
37588 if (PyErr_Occurred()) SWIG_fail;
37589 }
37590 {
37591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37592 }
37593 return resultobj;
37594 fail:
37595 return NULL;
37596 }
37597
37598
37599 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37600 PyObject *resultobj = 0;
37601 wxWindow *arg1 = (wxWindow *) 0 ;
37602 bool arg2 = (bool) true ;
37603 wxRect *arg3 = (wxRect *) NULL ;
37604 void *argp1 = 0 ;
37605 int res1 = 0 ;
37606 bool val2 ;
37607 int ecode2 = 0 ;
37608 void *argp3 = 0 ;
37609 int res3 = 0 ;
37610 PyObject * obj0 = 0 ;
37611 PyObject * obj1 = 0 ;
37612 PyObject * obj2 = 0 ;
37613 char * kwnames[] = {
37614 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37615 };
37616
37617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37619 if (!SWIG_IsOK(res1)) {
37620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37621 }
37622 arg1 = reinterpret_cast< wxWindow * >(argp1);
37623 if (obj1) {
37624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37625 if (!SWIG_IsOK(ecode2)) {
37626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37627 }
37628 arg2 = static_cast< bool >(val2);
37629 }
37630 if (obj2) {
37631 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37632 if (!SWIG_IsOK(res3)) {
37633 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37634 }
37635 arg3 = reinterpret_cast< wxRect * >(argp3);
37636 }
37637 {
37638 PyThreadState* __tstate = wxPyBeginAllowThreads();
37639 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37640 wxPyEndAllowThreads(__tstate);
37641 if (PyErr_Occurred()) SWIG_fail;
37642 }
37643 resultobj = SWIG_Py_Void();
37644 return resultobj;
37645 fail:
37646 return NULL;
37647 }
37648
37649
37650 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37651 PyObject *resultobj = 0;
37652 wxWindow *arg1 = (wxWindow *) 0 ;
37653 wxRect *arg2 = 0 ;
37654 bool arg3 = (bool) true ;
37655 void *argp1 = 0 ;
37656 int res1 = 0 ;
37657 wxRect temp2 ;
37658 bool val3 ;
37659 int ecode3 = 0 ;
37660 PyObject * obj0 = 0 ;
37661 PyObject * obj1 = 0 ;
37662 PyObject * obj2 = 0 ;
37663 char * kwnames[] = {
37664 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37665 };
37666
37667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37669 if (!SWIG_IsOK(res1)) {
37670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37671 }
37672 arg1 = reinterpret_cast< wxWindow * >(argp1);
37673 {
37674 arg2 = &temp2;
37675 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37676 }
37677 if (obj2) {
37678 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37679 if (!SWIG_IsOK(ecode3)) {
37680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37681 }
37682 arg3 = static_cast< bool >(val3);
37683 }
37684 {
37685 PyThreadState* __tstate = wxPyBeginAllowThreads();
37686 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37687 wxPyEndAllowThreads(__tstate);
37688 if (PyErr_Occurred()) SWIG_fail;
37689 }
37690 resultobj = SWIG_Py_Void();
37691 return resultobj;
37692 fail:
37693 return NULL;
37694 }
37695
37696
37697 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37698 PyObject *resultobj = 0;
37699 wxWindow *arg1 = (wxWindow *) 0 ;
37700 void *argp1 = 0 ;
37701 int res1 = 0 ;
37702 PyObject *swig_obj[1] ;
37703
37704 if (!args) SWIG_fail;
37705 swig_obj[0] = args;
37706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37707 if (!SWIG_IsOK(res1)) {
37708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37709 }
37710 arg1 = reinterpret_cast< wxWindow * >(argp1);
37711 {
37712 PyThreadState* __tstate = wxPyBeginAllowThreads();
37713 (arg1)->Update();
37714 wxPyEndAllowThreads(__tstate);
37715 if (PyErr_Occurred()) SWIG_fail;
37716 }
37717 resultobj = SWIG_Py_Void();
37718 return resultobj;
37719 fail:
37720 return NULL;
37721 }
37722
37723
37724 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37725 PyObject *resultobj = 0;
37726 wxWindow *arg1 = (wxWindow *) 0 ;
37727 void *argp1 = 0 ;
37728 int res1 = 0 ;
37729 PyObject *swig_obj[1] ;
37730
37731 if (!args) SWIG_fail;
37732 swig_obj[0] = args;
37733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37734 if (!SWIG_IsOK(res1)) {
37735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37736 }
37737 arg1 = reinterpret_cast< wxWindow * >(argp1);
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 (arg1)->ClearBackground();
37741 wxPyEndAllowThreads(__tstate);
37742 if (PyErr_Occurred()) SWIG_fail;
37743 }
37744 resultobj = SWIG_Py_Void();
37745 return resultobj;
37746 fail:
37747 return NULL;
37748 }
37749
37750
37751 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37752 PyObject *resultobj = 0;
37753 wxWindow *arg1 = (wxWindow *) 0 ;
37754 void *argp1 = 0 ;
37755 int res1 = 0 ;
37756 PyObject *swig_obj[1] ;
37757
37758 if (!args) SWIG_fail;
37759 swig_obj[0] = args;
37760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37761 if (!SWIG_IsOK(res1)) {
37762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37763 }
37764 arg1 = reinterpret_cast< wxWindow * >(argp1);
37765 {
37766 PyThreadState* __tstate = wxPyBeginAllowThreads();
37767 (arg1)->Freeze();
37768 wxPyEndAllowThreads(__tstate);
37769 if (PyErr_Occurred()) SWIG_fail;
37770 }
37771 resultobj = SWIG_Py_Void();
37772 return resultobj;
37773 fail:
37774 return NULL;
37775 }
37776
37777
37778 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37779 PyObject *resultobj = 0;
37780 wxWindow *arg1 = (wxWindow *) 0 ;
37781 bool result;
37782 void *argp1 = 0 ;
37783 int res1 = 0 ;
37784 PyObject *swig_obj[1] ;
37785
37786 if (!args) SWIG_fail;
37787 swig_obj[0] = args;
37788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37789 if (!SWIG_IsOK(res1)) {
37790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37791 }
37792 arg1 = reinterpret_cast< wxWindow * >(argp1);
37793 {
37794 PyThreadState* __tstate = wxPyBeginAllowThreads();
37795 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37796 wxPyEndAllowThreads(__tstate);
37797 if (PyErr_Occurred()) SWIG_fail;
37798 }
37799 {
37800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37801 }
37802 return resultobj;
37803 fail:
37804 return NULL;
37805 }
37806
37807
37808 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37809 PyObject *resultobj = 0;
37810 wxWindow *arg1 = (wxWindow *) 0 ;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 PyObject *swig_obj[1] ;
37814
37815 if (!args) SWIG_fail;
37816 swig_obj[0] = args;
37817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37818 if (!SWIG_IsOK(res1)) {
37819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37820 }
37821 arg1 = reinterpret_cast< wxWindow * >(argp1);
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 (arg1)->Thaw();
37825 wxPyEndAllowThreads(__tstate);
37826 if (PyErr_Occurred()) SWIG_fail;
37827 }
37828 resultobj = SWIG_Py_Void();
37829 return resultobj;
37830 fail:
37831 return NULL;
37832 }
37833
37834
37835 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37836 PyObject *resultobj = 0;
37837 wxWindow *arg1 = (wxWindow *) 0 ;
37838 wxDC *arg2 = 0 ;
37839 void *argp1 = 0 ;
37840 int res1 = 0 ;
37841 void *argp2 = 0 ;
37842 int res2 = 0 ;
37843 PyObject * obj0 = 0 ;
37844 PyObject * obj1 = 0 ;
37845 char * kwnames[] = {
37846 (char *) "self",(char *) "dc", NULL
37847 };
37848
37849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37851 if (!SWIG_IsOK(res1)) {
37852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37853 }
37854 arg1 = reinterpret_cast< wxWindow * >(argp1);
37855 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37856 if (!SWIG_IsOK(res2)) {
37857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37858 }
37859 if (!argp2) {
37860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37861 }
37862 arg2 = reinterpret_cast< wxDC * >(argp2);
37863 {
37864 PyThreadState* __tstate = wxPyBeginAllowThreads();
37865 (arg1)->PrepareDC(*arg2);
37866 wxPyEndAllowThreads(__tstate);
37867 if (PyErr_Occurred()) SWIG_fail;
37868 }
37869 resultobj = SWIG_Py_Void();
37870 return resultobj;
37871 fail:
37872 return NULL;
37873 }
37874
37875
37876 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37877 PyObject *resultobj = 0;
37878 wxWindow *arg1 = (wxWindow *) 0 ;
37879 bool result;
37880 void *argp1 = 0 ;
37881 int res1 = 0 ;
37882 PyObject *swig_obj[1] ;
37883
37884 if (!args) SWIG_fail;
37885 swig_obj[0] = args;
37886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37887 if (!SWIG_IsOK(res1)) {
37888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37889 }
37890 arg1 = reinterpret_cast< wxWindow * >(argp1);
37891 {
37892 PyThreadState* __tstate = wxPyBeginAllowThreads();
37893 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37894 wxPyEndAllowThreads(__tstate);
37895 if (PyErr_Occurred()) SWIG_fail;
37896 }
37897 {
37898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37899 }
37900 return resultobj;
37901 fail:
37902 return NULL;
37903 }
37904
37905
37906 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37907 PyObject *resultobj = 0;
37908 wxWindow *arg1 = (wxWindow *) 0 ;
37909 wxRegion *result = 0 ;
37910 void *argp1 = 0 ;
37911 int res1 = 0 ;
37912 PyObject *swig_obj[1] ;
37913
37914 if (!args) SWIG_fail;
37915 swig_obj[0] = args;
37916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37917 if (!SWIG_IsOK(res1)) {
37918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37919 }
37920 arg1 = reinterpret_cast< wxWindow * >(argp1);
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 {
37924 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37925 result = (wxRegion *) &_result_ref;
37926 }
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37938 PyObject *resultobj = 0;
37939 wxWindow *arg1 = (wxWindow *) 0 ;
37940 wxRect result;
37941 void *argp1 = 0 ;
37942 int res1 = 0 ;
37943 PyObject *swig_obj[1] ;
37944
37945 if (!args) SWIG_fail;
37946 swig_obj[0] = args;
37947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37948 if (!SWIG_IsOK(res1)) {
37949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37950 }
37951 arg1 = reinterpret_cast< wxWindow * >(argp1);
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37955 wxPyEndAllowThreads(__tstate);
37956 if (PyErr_Occurred()) SWIG_fail;
37957 }
37958 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37959 return resultobj;
37960 fail:
37961 return NULL;
37962 }
37963
37964
37965 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37966 PyObject *resultobj = 0;
37967 wxWindow *arg1 = (wxWindow *) 0 ;
37968 int arg2 ;
37969 int arg3 ;
37970 int arg4 = (int) 1 ;
37971 int arg5 = (int) 1 ;
37972 bool result;
37973 void *argp1 = 0 ;
37974 int res1 = 0 ;
37975 int val2 ;
37976 int ecode2 = 0 ;
37977 int val3 ;
37978 int ecode3 = 0 ;
37979 int val4 ;
37980 int ecode4 = 0 ;
37981 int val5 ;
37982 int ecode5 = 0 ;
37983 PyObject * obj0 = 0 ;
37984 PyObject * obj1 = 0 ;
37985 PyObject * obj2 = 0 ;
37986 PyObject * obj3 = 0 ;
37987 PyObject * obj4 = 0 ;
37988 char * kwnames[] = {
37989 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37990 };
37991
37992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37994 if (!SWIG_IsOK(res1)) {
37995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37996 }
37997 arg1 = reinterpret_cast< wxWindow * >(argp1);
37998 ecode2 = SWIG_AsVal_int(obj1, &val2);
37999 if (!SWIG_IsOK(ecode2)) {
38000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38001 }
38002 arg2 = static_cast< int >(val2);
38003 ecode3 = SWIG_AsVal_int(obj2, &val3);
38004 if (!SWIG_IsOK(ecode3)) {
38005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38006 }
38007 arg3 = static_cast< int >(val3);
38008 if (obj3) {
38009 ecode4 = SWIG_AsVal_int(obj3, &val4);
38010 if (!SWIG_IsOK(ecode4)) {
38011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38012 }
38013 arg4 = static_cast< int >(val4);
38014 }
38015 if (obj4) {
38016 ecode5 = SWIG_AsVal_int(obj4, &val5);
38017 if (!SWIG_IsOK(ecode5)) {
38018 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38019 }
38020 arg5 = static_cast< int >(val5);
38021 }
38022 {
38023 PyThreadState* __tstate = wxPyBeginAllowThreads();
38024 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38025 wxPyEndAllowThreads(__tstate);
38026 if (PyErr_Occurred()) SWIG_fail;
38027 }
38028 {
38029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38030 }
38031 return resultobj;
38032 fail:
38033 return NULL;
38034 }
38035
38036
38037 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38038 PyObject *resultobj = 0;
38039 wxWindow *arg1 = (wxWindow *) 0 ;
38040 wxPoint *arg2 = 0 ;
38041 bool result;
38042 void *argp1 = 0 ;
38043 int res1 = 0 ;
38044 wxPoint temp2 ;
38045 PyObject * obj0 = 0 ;
38046 PyObject * obj1 = 0 ;
38047 char * kwnames[] = {
38048 (char *) "self",(char *) "pt", NULL
38049 };
38050
38051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38053 if (!SWIG_IsOK(res1)) {
38054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38055 }
38056 arg1 = reinterpret_cast< wxWindow * >(argp1);
38057 {
38058 arg2 = &temp2;
38059 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38060 }
38061 {
38062 PyThreadState* __tstate = wxPyBeginAllowThreads();
38063 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38064 wxPyEndAllowThreads(__tstate);
38065 if (PyErr_Occurred()) SWIG_fail;
38066 }
38067 {
38068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38069 }
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38077 PyObject *resultobj = 0;
38078 wxWindow *arg1 = (wxWindow *) 0 ;
38079 wxRect *arg2 = 0 ;
38080 bool result;
38081 void *argp1 = 0 ;
38082 int res1 = 0 ;
38083 wxRect temp2 ;
38084 PyObject * obj0 = 0 ;
38085 PyObject * obj1 = 0 ;
38086 char * kwnames[] = {
38087 (char *) "self",(char *) "rect", NULL
38088 };
38089
38090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",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_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38094 }
38095 arg1 = reinterpret_cast< wxWindow * >(argp1);
38096 {
38097 arg2 = &temp2;
38098 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38099 }
38100 {
38101 PyThreadState* __tstate = wxPyBeginAllowThreads();
38102 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38103 wxPyEndAllowThreads(__tstate);
38104 if (PyErr_Occurred()) SWIG_fail;
38105 }
38106 {
38107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38108 }
38109 return resultobj;
38110 fail:
38111 return NULL;
38112 }
38113
38114
38115 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38116 PyObject *resultobj = 0;
38117 wxWindow *arg1 = (wxWindow *) 0 ;
38118 SwigValueWrapper<wxVisualAttributes > result;
38119 void *argp1 = 0 ;
38120 int res1 = 0 ;
38121 PyObject *swig_obj[1] ;
38122
38123 if (!args) SWIG_fail;
38124 swig_obj[0] = args;
38125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38126 if (!SWIG_IsOK(res1)) {
38127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38128 }
38129 arg1 = reinterpret_cast< wxWindow * >(argp1);
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38133 wxPyEndAllowThreads(__tstate);
38134 if (PyErr_Occurred()) SWIG_fail;
38135 }
38136 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38137 return resultobj;
38138 fail:
38139 return NULL;
38140 }
38141
38142
38143 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38144 PyObject *resultobj = 0;
38145 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38146 SwigValueWrapper<wxVisualAttributes > result;
38147 int val1 ;
38148 int ecode1 = 0 ;
38149 PyObject * obj0 = 0 ;
38150 char * kwnames[] = {
38151 (char *) "variant", NULL
38152 };
38153
38154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38155 if (obj0) {
38156 ecode1 = SWIG_AsVal_int(obj0, &val1);
38157 if (!SWIG_IsOK(ecode1)) {
38158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38159 }
38160 arg1 = static_cast< wxWindowVariant >(val1);
38161 }
38162 {
38163 if (!wxPyCheckForApp()) SWIG_fail;
38164 PyThreadState* __tstate = wxPyBeginAllowThreads();
38165 result = wxWindow::GetClassDefaultAttributes(arg1);
38166 wxPyEndAllowThreads(__tstate);
38167 if (PyErr_Occurred()) SWIG_fail;
38168 }
38169 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38170 return resultobj;
38171 fail:
38172 return NULL;
38173 }
38174
38175
38176 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38177 PyObject *resultobj = 0;
38178 wxWindow *arg1 = (wxWindow *) 0 ;
38179 wxColour *arg2 = 0 ;
38180 bool result;
38181 void *argp1 = 0 ;
38182 int res1 = 0 ;
38183 wxColour temp2 ;
38184 PyObject * obj0 = 0 ;
38185 PyObject * obj1 = 0 ;
38186 char * kwnames[] = {
38187 (char *) "self",(char *) "colour", NULL
38188 };
38189
38190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38192 if (!SWIG_IsOK(res1)) {
38193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38194 }
38195 arg1 = reinterpret_cast< wxWindow * >(argp1);
38196 {
38197 arg2 = &temp2;
38198 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38199 }
38200 {
38201 PyThreadState* __tstate = wxPyBeginAllowThreads();
38202 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38203 wxPyEndAllowThreads(__tstate);
38204 if (PyErr_Occurred()) SWIG_fail;
38205 }
38206 {
38207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38208 }
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj = 0;
38217 wxWindow *arg1 = (wxWindow *) 0 ;
38218 wxColour *arg2 = 0 ;
38219 void *argp1 = 0 ;
38220 int res1 = 0 ;
38221 wxColour temp2 ;
38222 PyObject * obj0 = 0 ;
38223 PyObject * obj1 = 0 ;
38224 char * kwnames[] = {
38225 (char *) "self",(char *) "colour", NULL
38226 };
38227
38228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38230 if (!SWIG_IsOK(res1)) {
38231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38232 }
38233 arg1 = reinterpret_cast< wxWindow * >(argp1);
38234 {
38235 arg2 = &temp2;
38236 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38237 }
38238 {
38239 PyThreadState* __tstate = wxPyBeginAllowThreads();
38240 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38241 wxPyEndAllowThreads(__tstate);
38242 if (PyErr_Occurred()) SWIG_fail;
38243 }
38244 resultobj = SWIG_Py_Void();
38245 return resultobj;
38246 fail:
38247 return NULL;
38248 }
38249
38250
38251 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38252 PyObject *resultobj = 0;
38253 wxWindow *arg1 = (wxWindow *) 0 ;
38254 wxColour *arg2 = 0 ;
38255 bool result;
38256 void *argp1 = 0 ;
38257 int res1 = 0 ;
38258 wxColour temp2 ;
38259 PyObject * obj0 = 0 ;
38260 PyObject * obj1 = 0 ;
38261 char * kwnames[] = {
38262 (char *) "self",(char *) "colour", NULL
38263 };
38264
38265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38267 if (!SWIG_IsOK(res1)) {
38268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38269 }
38270 arg1 = reinterpret_cast< wxWindow * >(argp1);
38271 {
38272 arg2 = &temp2;
38273 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38274 }
38275 {
38276 PyThreadState* __tstate = wxPyBeginAllowThreads();
38277 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38278 wxPyEndAllowThreads(__tstate);
38279 if (PyErr_Occurred()) SWIG_fail;
38280 }
38281 {
38282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38283 }
38284 return resultobj;
38285 fail:
38286 return NULL;
38287 }
38288
38289
38290 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38291 PyObject *resultobj = 0;
38292 wxWindow *arg1 = (wxWindow *) 0 ;
38293 wxColour *arg2 = 0 ;
38294 void *argp1 = 0 ;
38295 int res1 = 0 ;
38296 wxColour temp2 ;
38297 PyObject * obj0 = 0 ;
38298 PyObject * obj1 = 0 ;
38299 char * kwnames[] = {
38300 (char *) "self",(char *) "colour", NULL
38301 };
38302
38303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38305 if (!SWIG_IsOK(res1)) {
38306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38307 }
38308 arg1 = reinterpret_cast< wxWindow * >(argp1);
38309 {
38310 arg2 = &temp2;
38311 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38312 }
38313 {
38314 PyThreadState* __tstate = wxPyBeginAllowThreads();
38315 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38316 wxPyEndAllowThreads(__tstate);
38317 if (PyErr_Occurred()) SWIG_fail;
38318 }
38319 resultobj = SWIG_Py_Void();
38320 return resultobj;
38321 fail:
38322 return NULL;
38323 }
38324
38325
38326 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38327 PyObject *resultobj = 0;
38328 wxWindow *arg1 = (wxWindow *) 0 ;
38329 wxColour result;
38330 void *argp1 = 0 ;
38331 int res1 = 0 ;
38332 PyObject *swig_obj[1] ;
38333
38334 if (!args) SWIG_fail;
38335 swig_obj[0] = args;
38336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38337 if (!SWIG_IsOK(res1)) {
38338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38339 }
38340 arg1 = reinterpret_cast< wxWindow * >(argp1);
38341 {
38342 PyThreadState* __tstate = wxPyBeginAllowThreads();
38343 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38344 wxPyEndAllowThreads(__tstate);
38345 if (PyErr_Occurred()) SWIG_fail;
38346 }
38347 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38348 return resultobj;
38349 fail:
38350 return NULL;
38351 }
38352
38353
38354 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38355 PyObject *resultobj = 0;
38356 wxWindow *arg1 = (wxWindow *) 0 ;
38357 wxColour result;
38358 void *argp1 = 0 ;
38359 int res1 = 0 ;
38360 PyObject *swig_obj[1] ;
38361
38362 if (!args) SWIG_fail;
38363 swig_obj[0] = args;
38364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38365 if (!SWIG_IsOK(res1)) {
38366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38367 }
38368 arg1 = reinterpret_cast< wxWindow * >(argp1);
38369 {
38370 PyThreadState* __tstate = wxPyBeginAllowThreads();
38371 result = ((wxWindow const *)arg1)->GetForegroundColour();
38372 wxPyEndAllowThreads(__tstate);
38373 if (PyErr_Occurred()) SWIG_fail;
38374 }
38375 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38376 return resultobj;
38377 fail:
38378 return NULL;
38379 }
38380
38381
38382 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38383 PyObject *resultobj = 0;
38384 wxWindow *arg1 = (wxWindow *) 0 ;
38385 bool result;
38386 void *argp1 = 0 ;
38387 int res1 = 0 ;
38388 PyObject *swig_obj[1] ;
38389
38390 if (!args) SWIG_fail;
38391 swig_obj[0] = args;
38392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38393 if (!SWIG_IsOK(res1)) {
38394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38395 }
38396 arg1 = reinterpret_cast< wxWindow * >(argp1);
38397 {
38398 PyThreadState* __tstate = wxPyBeginAllowThreads();
38399 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38400 wxPyEndAllowThreads(__tstate);
38401 if (PyErr_Occurred()) SWIG_fail;
38402 }
38403 {
38404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38405 }
38406 return resultobj;
38407 fail:
38408 return NULL;
38409 }
38410
38411
38412 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38413 PyObject *resultobj = 0;
38414 wxWindow *arg1 = (wxWindow *) 0 ;
38415 bool result;
38416 void *argp1 = 0 ;
38417 int res1 = 0 ;
38418 PyObject *swig_obj[1] ;
38419
38420 if (!args) SWIG_fail;
38421 swig_obj[0] = args;
38422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38423 if (!SWIG_IsOK(res1)) {
38424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38425 }
38426 arg1 = reinterpret_cast< wxWindow * >(argp1);
38427 {
38428 PyThreadState* __tstate = wxPyBeginAllowThreads();
38429 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38430 wxPyEndAllowThreads(__tstate);
38431 if (PyErr_Occurred()) SWIG_fail;
38432 }
38433 {
38434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38435 }
38436 return resultobj;
38437 fail:
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38443 PyObject *resultobj = 0;
38444 wxWindow *arg1 = (wxWindow *) 0 ;
38445 wxBackgroundStyle arg2 ;
38446 bool result;
38447 void *argp1 = 0 ;
38448 int res1 = 0 ;
38449 int val2 ;
38450 int ecode2 = 0 ;
38451 PyObject * obj0 = 0 ;
38452 PyObject * obj1 = 0 ;
38453 char * kwnames[] = {
38454 (char *) "self",(char *) "style", NULL
38455 };
38456
38457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38459 if (!SWIG_IsOK(res1)) {
38460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38461 }
38462 arg1 = reinterpret_cast< wxWindow * >(argp1);
38463 ecode2 = SWIG_AsVal_int(obj1, &val2);
38464 if (!SWIG_IsOK(ecode2)) {
38465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38466 }
38467 arg2 = static_cast< wxBackgroundStyle >(val2);
38468 {
38469 PyThreadState* __tstate = wxPyBeginAllowThreads();
38470 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38471 wxPyEndAllowThreads(__tstate);
38472 if (PyErr_Occurred()) SWIG_fail;
38473 }
38474 {
38475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38476 }
38477 return resultobj;
38478 fail:
38479 return NULL;
38480 }
38481
38482
38483 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38484 PyObject *resultobj = 0;
38485 wxWindow *arg1 = (wxWindow *) 0 ;
38486 wxBackgroundStyle result;
38487 void *argp1 = 0 ;
38488 int res1 = 0 ;
38489 PyObject *swig_obj[1] ;
38490
38491 if (!args) SWIG_fail;
38492 swig_obj[0] = args;
38493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38494 if (!SWIG_IsOK(res1)) {
38495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38496 }
38497 arg1 = reinterpret_cast< wxWindow * >(argp1);
38498 {
38499 PyThreadState* __tstate = wxPyBeginAllowThreads();
38500 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38501 wxPyEndAllowThreads(__tstate);
38502 if (PyErr_Occurred()) SWIG_fail;
38503 }
38504 resultobj = SWIG_From_int(static_cast< int >(result));
38505 return resultobj;
38506 fail:
38507 return NULL;
38508 }
38509
38510
38511 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38512 PyObject *resultobj = 0;
38513 wxWindow *arg1 = (wxWindow *) 0 ;
38514 bool result;
38515 void *argp1 = 0 ;
38516 int res1 = 0 ;
38517 PyObject *swig_obj[1] ;
38518
38519 if (!args) SWIG_fail;
38520 swig_obj[0] = args;
38521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38522 if (!SWIG_IsOK(res1)) {
38523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38524 }
38525 arg1 = reinterpret_cast< wxWindow * >(argp1);
38526 {
38527 PyThreadState* __tstate = wxPyBeginAllowThreads();
38528 result = (bool)(arg1)->HasTransparentBackground();
38529 wxPyEndAllowThreads(__tstate);
38530 if (PyErr_Occurred()) SWIG_fail;
38531 }
38532 {
38533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38534 }
38535 return resultobj;
38536 fail:
38537 return NULL;
38538 }
38539
38540
38541 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38542 PyObject *resultobj = 0;
38543 wxWindow *arg1 = (wxWindow *) 0 ;
38544 wxCursor *arg2 = 0 ;
38545 bool result;
38546 void *argp1 = 0 ;
38547 int res1 = 0 ;
38548 void *argp2 = 0 ;
38549 int res2 = 0 ;
38550 PyObject * obj0 = 0 ;
38551 PyObject * obj1 = 0 ;
38552 char * kwnames[] = {
38553 (char *) "self",(char *) "cursor", NULL
38554 };
38555
38556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38558 if (!SWIG_IsOK(res1)) {
38559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38560 }
38561 arg1 = reinterpret_cast< wxWindow * >(argp1);
38562 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38563 if (!SWIG_IsOK(res2)) {
38564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38565 }
38566 if (!argp2) {
38567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38568 }
38569 arg2 = reinterpret_cast< wxCursor * >(argp2);
38570 {
38571 PyThreadState* __tstate = wxPyBeginAllowThreads();
38572 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38573 wxPyEndAllowThreads(__tstate);
38574 if (PyErr_Occurred()) SWIG_fail;
38575 }
38576 {
38577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38578 }
38579 return resultobj;
38580 fail:
38581 return NULL;
38582 }
38583
38584
38585 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38586 PyObject *resultobj = 0;
38587 wxWindow *arg1 = (wxWindow *) 0 ;
38588 wxCursor result;
38589 void *argp1 = 0 ;
38590 int res1 = 0 ;
38591 PyObject *swig_obj[1] ;
38592
38593 if (!args) SWIG_fail;
38594 swig_obj[0] = args;
38595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38596 if (!SWIG_IsOK(res1)) {
38597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38598 }
38599 arg1 = reinterpret_cast< wxWindow * >(argp1);
38600 {
38601 PyThreadState* __tstate = wxPyBeginAllowThreads();
38602 result = (arg1)->GetCursor();
38603 wxPyEndAllowThreads(__tstate);
38604 if (PyErr_Occurred()) SWIG_fail;
38605 }
38606 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38607 return resultobj;
38608 fail:
38609 return NULL;
38610 }
38611
38612
38613 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38614 PyObject *resultobj = 0;
38615 wxWindow *arg1 = (wxWindow *) 0 ;
38616 wxFont *arg2 = 0 ;
38617 bool result;
38618 void *argp1 = 0 ;
38619 int res1 = 0 ;
38620 void *argp2 = 0 ;
38621 int res2 = 0 ;
38622 PyObject * obj0 = 0 ;
38623 PyObject * obj1 = 0 ;
38624 char * kwnames[] = {
38625 (char *) "self",(char *) "font", NULL
38626 };
38627
38628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38630 if (!SWIG_IsOK(res1)) {
38631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38632 }
38633 arg1 = reinterpret_cast< wxWindow * >(argp1);
38634 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38635 if (!SWIG_IsOK(res2)) {
38636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38637 }
38638 if (!argp2) {
38639 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38640 }
38641 arg2 = reinterpret_cast< wxFont * >(argp2);
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38645 wxPyEndAllowThreads(__tstate);
38646 if (PyErr_Occurred()) SWIG_fail;
38647 }
38648 {
38649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38650 }
38651 return resultobj;
38652 fail:
38653 return NULL;
38654 }
38655
38656
38657 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38658 PyObject *resultobj = 0;
38659 wxWindow *arg1 = (wxWindow *) 0 ;
38660 wxFont *arg2 = 0 ;
38661 void *argp1 = 0 ;
38662 int res1 = 0 ;
38663 void *argp2 = 0 ;
38664 int res2 = 0 ;
38665 PyObject * obj0 = 0 ;
38666 PyObject * obj1 = 0 ;
38667 char * kwnames[] = {
38668 (char *) "self",(char *) "font", NULL
38669 };
38670
38671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38673 if (!SWIG_IsOK(res1)) {
38674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38675 }
38676 arg1 = reinterpret_cast< wxWindow * >(argp1);
38677 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38678 if (!SWIG_IsOK(res2)) {
38679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38680 }
38681 if (!argp2) {
38682 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38683 }
38684 arg2 = reinterpret_cast< wxFont * >(argp2);
38685 {
38686 PyThreadState* __tstate = wxPyBeginAllowThreads();
38687 (arg1)->SetOwnFont((wxFont const &)*arg2);
38688 wxPyEndAllowThreads(__tstate);
38689 if (PyErr_Occurred()) SWIG_fail;
38690 }
38691 resultobj = SWIG_Py_Void();
38692 return resultobj;
38693 fail:
38694 return NULL;
38695 }
38696
38697
38698 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38699 PyObject *resultobj = 0;
38700 wxWindow *arg1 = (wxWindow *) 0 ;
38701 wxFont result;
38702 void *argp1 = 0 ;
38703 int res1 = 0 ;
38704 PyObject *swig_obj[1] ;
38705
38706 if (!args) SWIG_fail;
38707 swig_obj[0] = args;
38708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38709 if (!SWIG_IsOK(res1)) {
38710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38711 }
38712 arg1 = reinterpret_cast< wxWindow * >(argp1);
38713 {
38714 PyThreadState* __tstate = wxPyBeginAllowThreads();
38715 result = (arg1)->GetFont();
38716 wxPyEndAllowThreads(__tstate);
38717 if (PyErr_Occurred()) SWIG_fail;
38718 }
38719 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38720 return resultobj;
38721 fail:
38722 return NULL;
38723 }
38724
38725
38726 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38727 PyObject *resultobj = 0;
38728 wxWindow *arg1 = (wxWindow *) 0 ;
38729 wxCaret *arg2 = (wxCaret *) 0 ;
38730 void *argp1 = 0 ;
38731 int res1 = 0 ;
38732 int res2 = 0 ;
38733 PyObject * obj0 = 0 ;
38734 PyObject * obj1 = 0 ;
38735 char * kwnames[] = {
38736 (char *) "self",(char *) "caret", NULL
38737 };
38738
38739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38741 if (!SWIG_IsOK(res1)) {
38742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38743 }
38744 arg1 = reinterpret_cast< wxWindow * >(argp1);
38745 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38746 if (!SWIG_IsOK(res2)) {
38747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38748 }
38749 {
38750 PyThreadState* __tstate = wxPyBeginAllowThreads();
38751 (arg1)->SetCaret(arg2);
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 resultobj = SWIG_Py_Void();
38756 return resultobj;
38757 fail:
38758 return NULL;
38759 }
38760
38761
38762 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38763 PyObject *resultobj = 0;
38764 wxWindow *arg1 = (wxWindow *) 0 ;
38765 wxCaret *result = 0 ;
38766 void *argp1 = 0 ;
38767 int res1 = 0 ;
38768 PyObject *swig_obj[1] ;
38769
38770 if (!args) SWIG_fail;
38771 swig_obj[0] = args;
38772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38773 if (!SWIG_IsOK(res1)) {
38774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38775 }
38776 arg1 = reinterpret_cast< wxWindow * >(argp1);
38777 {
38778 PyThreadState* __tstate = wxPyBeginAllowThreads();
38779 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38780 wxPyEndAllowThreads(__tstate);
38781 if (PyErr_Occurred()) SWIG_fail;
38782 }
38783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38784 return resultobj;
38785 fail:
38786 return NULL;
38787 }
38788
38789
38790 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38791 PyObject *resultobj = 0;
38792 wxWindow *arg1 = (wxWindow *) 0 ;
38793 int result;
38794 void *argp1 = 0 ;
38795 int res1 = 0 ;
38796 PyObject *swig_obj[1] ;
38797
38798 if (!args) SWIG_fail;
38799 swig_obj[0] = args;
38800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38803 }
38804 arg1 = reinterpret_cast< wxWindow * >(argp1);
38805 {
38806 PyThreadState* __tstate = wxPyBeginAllowThreads();
38807 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38808 wxPyEndAllowThreads(__tstate);
38809 if (PyErr_Occurred()) SWIG_fail;
38810 }
38811 resultobj = SWIG_From_int(static_cast< int >(result));
38812 return resultobj;
38813 fail:
38814 return NULL;
38815 }
38816
38817
38818 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38819 PyObject *resultobj = 0;
38820 wxWindow *arg1 = (wxWindow *) 0 ;
38821 int result;
38822 void *argp1 = 0 ;
38823 int res1 = 0 ;
38824 PyObject *swig_obj[1] ;
38825
38826 if (!args) SWIG_fail;
38827 swig_obj[0] = args;
38828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38829 if (!SWIG_IsOK(res1)) {
38830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38831 }
38832 arg1 = reinterpret_cast< wxWindow * >(argp1);
38833 {
38834 PyThreadState* __tstate = wxPyBeginAllowThreads();
38835 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38836 wxPyEndAllowThreads(__tstate);
38837 if (PyErr_Occurred()) SWIG_fail;
38838 }
38839 resultobj = SWIG_From_int(static_cast< int >(result));
38840 return resultobj;
38841 fail:
38842 return NULL;
38843 }
38844
38845
38846 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38847 PyObject *resultobj = 0;
38848 wxWindow *arg1 = (wxWindow *) 0 ;
38849 wxString *arg2 = 0 ;
38850 int *arg3 = (int *) 0 ;
38851 int *arg4 = (int *) 0 ;
38852 void *argp1 = 0 ;
38853 int res1 = 0 ;
38854 bool temp2 = false ;
38855 int temp3 ;
38856 int res3 = SWIG_TMPOBJ ;
38857 int temp4 ;
38858 int res4 = SWIG_TMPOBJ ;
38859 PyObject * obj0 = 0 ;
38860 PyObject * obj1 = 0 ;
38861 char * kwnames[] = {
38862 (char *) "self",(char *) "string", NULL
38863 };
38864
38865 arg3 = &temp3;
38866 arg4 = &temp4;
38867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38869 if (!SWIG_IsOK(res1)) {
38870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38871 }
38872 arg1 = reinterpret_cast< wxWindow * >(argp1);
38873 {
38874 arg2 = wxString_in_helper(obj1);
38875 if (arg2 == NULL) SWIG_fail;
38876 temp2 = true;
38877 }
38878 {
38879 PyThreadState* __tstate = wxPyBeginAllowThreads();
38880 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38881 wxPyEndAllowThreads(__tstate);
38882 if (PyErr_Occurred()) SWIG_fail;
38883 }
38884 resultobj = SWIG_Py_Void();
38885 if (SWIG_IsTmpObj(res3)) {
38886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38887 } else {
38888 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38890 }
38891 if (SWIG_IsTmpObj(res4)) {
38892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38893 } else {
38894 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38896 }
38897 {
38898 if (temp2)
38899 delete arg2;
38900 }
38901 return resultobj;
38902 fail:
38903 {
38904 if (temp2)
38905 delete arg2;
38906 }
38907 return NULL;
38908 }
38909
38910
38911 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38912 PyObject *resultobj = 0;
38913 wxWindow *arg1 = (wxWindow *) 0 ;
38914 wxString *arg2 = 0 ;
38915 int *arg3 = (int *) 0 ;
38916 int *arg4 = (int *) 0 ;
38917 int *arg5 = (int *) 0 ;
38918 int *arg6 = (int *) 0 ;
38919 wxFont *arg7 = (wxFont *) NULL ;
38920 void *argp1 = 0 ;
38921 int res1 = 0 ;
38922 bool temp2 = false ;
38923 int temp3 ;
38924 int res3 = SWIG_TMPOBJ ;
38925 int temp4 ;
38926 int res4 = SWIG_TMPOBJ ;
38927 int temp5 ;
38928 int res5 = SWIG_TMPOBJ ;
38929 int temp6 ;
38930 int res6 = SWIG_TMPOBJ ;
38931 void *argp7 = 0 ;
38932 int res7 = 0 ;
38933 PyObject * obj0 = 0 ;
38934 PyObject * obj1 = 0 ;
38935 PyObject * obj2 = 0 ;
38936 char * kwnames[] = {
38937 (char *) "self",(char *) "string",(char *) "font", NULL
38938 };
38939
38940 arg3 = &temp3;
38941 arg4 = &temp4;
38942 arg5 = &temp5;
38943 arg6 = &temp6;
38944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38946 if (!SWIG_IsOK(res1)) {
38947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38948 }
38949 arg1 = reinterpret_cast< wxWindow * >(argp1);
38950 {
38951 arg2 = wxString_in_helper(obj1);
38952 if (arg2 == NULL) SWIG_fail;
38953 temp2 = true;
38954 }
38955 if (obj2) {
38956 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38957 if (!SWIG_IsOK(res7)) {
38958 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38959 }
38960 arg7 = reinterpret_cast< wxFont * >(argp7);
38961 }
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38965 wxPyEndAllowThreads(__tstate);
38966 if (PyErr_Occurred()) SWIG_fail;
38967 }
38968 resultobj = SWIG_Py_Void();
38969 if (SWIG_IsTmpObj(res3)) {
38970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38971 } else {
38972 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38974 }
38975 if (SWIG_IsTmpObj(res4)) {
38976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38977 } else {
38978 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38980 }
38981 if (SWIG_IsTmpObj(res5)) {
38982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38983 } else {
38984 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38986 }
38987 if (SWIG_IsTmpObj(res6)) {
38988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38989 } else {
38990 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38992 }
38993 {
38994 if (temp2)
38995 delete arg2;
38996 }
38997 return resultobj;
38998 fail:
38999 {
39000 if (temp2)
39001 delete arg2;
39002 }
39003 return NULL;
39004 }
39005
39006
39007 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39008 PyObject *resultobj = 0;
39009 wxWindow *arg1 = (wxWindow *) 0 ;
39010 int *arg2 = (int *) 0 ;
39011 int *arg3 = (int *) 0 ;
39012 void *argp1 = 0 ;
39013 int res1 = 0 ;
39014 int temp2 ;
39015 int res2 = 0 ;
39016 int temp3 ;
39017 int res3 = 0 ;
39018 PyObject * obj0 = 0 ;
39019 PyObject * obj1 = 0 ;
39020 PyObject * obj2 = 0 ;
39021 char * kwnames[] = {
39022 (char *) "self",(char *) "x",(char *) "y", NULL
39023 };
39024
39025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39027 if (!SWIG_IsOK(res1)) {
39028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39029 }
39030 arg1 = reinterpret_cast< wxWindow * >(argp1);
39031 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39032 int val;
39033 int ecode = SWIG_AsVal_int(obj1, &val);
39034 if (!SWIG_IsOK(ecode)) {
39035 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39036 }
39037 temp2 = static_cast< int >(val);
39038 arg2 = &temp2;
39039 res2 = SWIG_AddTmpMask(ecode);
39040 }
39041 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39042 int val;
39043 int ecode = SWIG_AsVal_int(obj2, &val);
39044 if (!SWIG_IsOK(ecode)) {
39045 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39046 }
39047 temp3 = static_cast< int >(val);
39048 arg3 = &temp3;
39049 res3 = SWIG_AddTmpMask(ecode);
39050 }
39051 {
39052 PyThreadState* __tstate = wxPyBeginAllowThreads();
39053 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39054 wxPyEndAllowThreads(__tstate);
39055 if (PyErr_Occurred()) SWIG_fail;
39056 }
39057 resultobj = SWIG_Py_Void();
39058 if (SWIG_IsTmpObj(res2)) {
39059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39060 } else {
39061 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39063 }
39064 if (SWIG_IsTmpObj(res3)) {
39065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39066 } else {
39067 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39069 }
39070 return resultobj;
39071 fail:
39072 return NULL;
39073 }
39074
39075
39076 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39077 PyObject *resultobj = 0;
39078 wxWindow *arg1 = (wxWindow *) 0 ;
39079 int *arg2 = (int *) 0 ;
39080 int *arg3 = (int *) 0 ;
39081 void *argp1 = 0 ;
39082 int res1 = 0 ;
39083 int temp2 ;
39084 int res2 = 0 ;
39085 int temp3 ;
39086 int res3 = 0 ;
39087 PyObject * obj0 = 0 ;
39088 PyObject * obj1 = 0 ;
39089 PyObject * obj2 = 0 ;
39090 char * kwnames[] = {
39091 (char *) "self",(char *) "x",(char *) "y", NULL
39092 };
39093
39094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39096 if (!SWIG_IsOK(res1)) {
39097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39098 }
39099 arg1 = reinterpret_cast< wxWindow * >(argp1);
39100 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39101 int val;
39102 int ecode = SWIG_AsVal_int(obj1, &val);
39103 if (!SWIG_IsOK(ecode)) {
39104 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39105 }
39106 temp2 = static_cast< int >(val);
39107 arg2 = &temp2;
39108 res2 = SWIG_AddTmpMask(ecode);
39109 }
39110 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39111 int val;
39112 int ecode = SWIG_AsVal_int(obj2, &val);
39113 if (!SWIG_IsOK(ecode)) {
39114 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39115 }
39116 temp3 = static_cast< int >(val);
39117 arg3 = &temp3;
39118 res3 = SWIG_AddTmpMask(ecode);
39119 }
39120 {
39121 PyThreadState* __tstate = wxPyBeginAllowThreads();
39122 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39123 wxPyEndAllowThreads(__tstate);
39124 if (PyErr_Occurred()) SWIG_fail;
39125 }
39126 resultobj = SWIG_Py_Void();
39127 if (SWIG_IsTmpObj(res2)) {
39128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39129 } else {
39130 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39132 }
39133 if (SWIG_IsTmpObj(res3)) {
39134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39135 } else {
39136 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39138 }
39139 return resultobj;
39140 fail:
39141 return NULL;
39142 }
39143
39144
39145 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39146 PyObject *resultobj = 0;
39147 wxWindow *arg1 = (wxWindow *) 0 ;
39148 wxPoint *arg2 = 0 ;
39149 wxPoint result;
39150 void *argp1 = 0 ;
39151 int res1 = 0 ;
39152 wxPoint temp2 ;
39153 PyObject * obj0 = 0 ;
39154 PyObject * obj1 = 0 ;
39155 char * kwnames[] = {
39156 (char *) "self",(char *) "pt", NULL
39157 };
39158
39159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39161 if (!SWIG_IsOK(res1)) {
39162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39163 }
39164 arg1 = reinterpret_cast< wxWindow * >(argp1);
39165 {
39166 arg2 = &temp2;
39167 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39168 }
39169 {
39170 PyThreadState* __tstate = wxPyBeginAllowThreads();
39171 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39172 wxPyEndAllowThreads(__tstate);
39173 if (PyErr_Occurred()) SWIG_fail;
39174 }
39175 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39176 return resultobj;
39177 fail:
39178 return NULL;
39179 }
39180
39181
39182 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39183 PyObject *resultobj = 0;
39184 wxWindow *arg1 = (wxWindow *) 0 ;
39185 wxPoint *arg2 = 0 ;
39186 wxPoint result;
39187 void *argp1 = 0 ;
39188 int res1 = 0 ;
39189 wxPoint temp2 ;
39190 PyObject * obj0 = 0 ;
39191 PyObject * obj1 = 0 ;
39192 char * kwnames[] = {
39193 (char *) "self",(char *) "pt", NULL
39194 };
39195
39196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39198 if (!SWIG_IsOK(res1)) {
39199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39200 }
39201 arg1 = reinterpret_cast< wxWindow * >(argp1);
39202 {
39203 arg2 = &temp2;
39204 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39205 }
39206 {
39207 PyThreadState* __tstate = wxPyBeginAllowThreads();
39208 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39209 wxPyEndAllowThreads(__tstate);
39210 if (PyErr_Occurred()) SWIG_fail;
39211 }
39212 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39213 return resultobj;
39214 fail:
39215 return NULL;
39216 }
39217
39218
39219 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39220 PyObject *resultobj = 0;
39221 wxWindow *arg1 = (wxWindow *) 0 ;
39222 int arg2 ;
39223 int arg3 ;
39224 wxHitTest result;
39225 void *argp1 = 0 ;
39226 int res1 = 0 ;
39227 int val2 ;
39228 int ecode2 = 0 ;
39229 int val3 ;
39230 int ecode3 = 0 ;
39231 PyObject * obj0 = 0 ;
39232 PyObject * obj1 = 0 ;
39233 PyObject * obj2 = 0 ;
39234 char * kwnames[] = {
39235 (char *) "self",(char *) "x",(char *) "y", NULL
39236 };
39237
39238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39240 if (!SWIG_IsOK(res1)) {
39241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39242 }
39243 arg1 = reinterpret_cast< wxWindow * >(argp1);
39244 ecode2 = SWIG_AsVal_int(obj1, &val2);
39245 if (!SWIG_IsOK(ecode2)) {
39246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39247 }
39248 arg2 = static_cast< int >(val2);
39249 ecode3 = SWIG_AsVal_int(obj2, &val3);
39250 if (!SWIG_IsOK(ecode3)) {
39251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39252 }
39253 arg3 = static_cast< int >(val3);
39254 {
39255 PyThreadState* __tstate = wxPyBeginAllowThreads();
39256 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39257 wxPyEndAllowThreads(__tstate);
39258 if (PyErr_Occurred()) SWIG_fail;
39259 }
39260 resultobj = SWIG_From_int(static_cast< int >(result));
39261 return resultobj;
39262 fail:
39263 return NULL;
39264 }
39265
39266
39267 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39268 PyObject *resultobj = 0;
39269 wxWindow *arg1 = (wxWindow *) 0 ;
39270 wxPoint *arg2 = 0 ;
39271 wxHitTest result;
39272 void *argp1 = 0 ;
39273 int res1 = 0 ;
39274 wxPoint temp2 ;
39275 PyObject * obj0 = 0 ;
39276 PyObject * obj1 = 0 ;
39277 char * kwnames[] = {
39278 (char *) "self",(char *) "pt", NULL
39279 };
39280
39281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39283 if (!SWIG_IsOK(res1)) {
39284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39285 }
39286 arg1 = reinterpret_cast< wxWindow * >(argp1);
39287 {
39288 arg2 = &temp2;
39289 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39290 }
39291 {
39292 PyThreadState* __tstate = wxPyBeginAllowThreads();
39293 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39294 wxPyEndAllowThreads(__tstate);
39295 if (PyErr_Occurred()) SWIG_fail;
39296 }
39297 resultobj = SWIG_From_int(static_cast< int >(result));
39298 return resultobj;
39299 fail:
39300 return NULL;
39301 }
39302
39303
39304 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39305 PyObject *resultobj = 0;
39306 wxWindow *arg1 = (wxWindow *) 0 ;
39307 long arg2 ;
39308 wxBorder result;
39309 void *argp1 = 0 ;
39310 int res1 = 0 ;
39311 long val2 ;
39312 int ecode2 = 0 ;
39313
39314 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39316 if (!SWIG_IsOK(res1)) {
39317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39318 }
39319 arg1 = reinterpret_cast< wxWindow * >(argp1);
39320 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39321 if (!SWIG_IsOK(ecode2)) {
39322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39323 }
39324 arg2 = static_cast< long >(val2);
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39328 wxPyEndAllowThreads(__tstate);
39329 if (PyErr_Occurred()) SWIG_fail;
39330 }
39331 resultobj = SWIG_From_int(static_cast< int >(result));
39332 return resultobj;
39333 fail:
39334 return NULL;
39335 }
39336
39337
39338 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39339 PyObject *resultobj = 0;
39340 wxWindow *arg1 = (wxWindow *) 0 ;
39341 wxBorder result;
39342 void *argp1 = 0 ;
39343 int res1 = 0 ;
39344
39345 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39347 if (!SWIG_IsOK(res1)) {
39348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39349 }
39350 arg1 = reinterpret_cast< wxWindow * >(argp1);
39351 {
39352 PyThreadState* __tstate = wxPyBeginAllowThreads();
39353 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39354 wxPyEndAllowThreads(__tstate);
39355 if (PyErr_Occurred()) SWIG_fail;
39356 }
39357 resultobj = SWIG_From_int(static_cast< int >(result));
39358 return resultobj;
39359 fail:
39360 return NULL;
39361 }
39362
39363
39364 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39365 int argc;
39366 PyObject *argv[3];
39367
39368 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39369 --argc;
39370 if (argc == 1) {
39371 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39372 }
39373 if (argc == 2) {
39374 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39375 }
39376
39377 fail:
39378 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39379 return NULL;
39380 }
39381
39382
39383 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39384 PyObject *resultobj = 0;
39385 wxWindow *arg1 = (wxWindow *) 0 ;
39386 long arg2 = (long) wxUPDATE_UI_NONE ;
39387 void *argp1 = 0 ;
39388 int res1 = 0 ;
39389 long val2 ;
39390 int ecode2 = 0 ;
39391 PyObject * obj0 = 0 ;
39392 PyObject * obj1 = 0 ;
39393 char * kwnames[] = {
39394 (char *) "self",(char *) "flags", NULL
39395 };
39396
39397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39399 if (!SWIG_IsOK(res1)) {
39400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39401 }
39402 arg1 = reinterpret_cast< wxWindow * >(argp1);
39403 if (obj1) {
39404 ecode2 = SWIG_AsVal_long(obj1, &val2);
39405 if (!SWIG_IsOK(ecode2)) {
39406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39407 }
39408 arg2 = static_cast< long >(val2);
39409 }
39410 {
39411 PyThreadState* __tstate = wxPyBeginAllowThreads();
39412 (arg1)->UpdateWindowUI(arg2);
39413 wxPyEndAllowThreads(__tstate);
39414 if (PyErr_Occurred()) SWIG_fail;
39415 }
39416 resultobj = SWIG_Py_Void();
39417 return resultobj;
39418 fail:
39419 return NULL;
39420 }
39421
39422
39423 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39424 PyObject *resultobj = 0;
39425 wxWindow *arg1 = (wxWindow *) 0 ;
39426 wxMenu *arg2 = (wxMenu *) 0 ;
39427 int arg3 = (int) -1 ;
39428 int arg4 = (int) -1 ;
39429 bool result;
39430 void *argp1 = 0 ;
39431 int res1 = 0 ;
39432 void *argp2 = 0 ;
39433 int res2 = 0 ;
39434 int val3 ;
39435 int ecode3 = 0 ;
39436 int val4 ;
39437 int ecode4 = 0 ;
39438 PyObject * obj0 = 0 ;
39439 PyObject * obj1 = 0 ;
39440 PyObject * obj2 = 0 ;
39441 PyObject * obj3 = 0 ;
39442 char * kwnames[] = {
39443 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39444 };
39445
39446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39448 if (!SWIG_IsOK(res1)) {
39449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39450 }
39451 arg1 = reinterpret_cast< wxWindow * >(argp1);
39452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39453 if (!SWIG_IsOK(res2)) {
39454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39455 }
39456 arg2 = reinterpret_cast< wxMenu * >(argp2);
39457 if (obj2) {
39458 ecode3 = SWIG_AsVal_int(obj2, &val3);
39459 if (!SWIG_IsOK(ecode3)) {
39460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39461 }
39462 arg3 = static_cast< int >(val3);
39463 }
39464 if (obj3) {
39465 ecode4 = SWIG_AsVal_int(obj3, &val4);
39466 if (!SWIG_IsOK(ecode4)) {
39467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39468 }
39469 arg4 = static_cast< int >(val4);
39470 }
39471 {
39472 PyThreadState* __tstate = wxPyBeginAllowThreads();
39473 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39474 wxPyEndAllowThreads(__tstate);
39475 if (PyErr_Occurred()) SWIG_fail;
39476 }
39477 {
39478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39479 }
39480 return resultobj;
39481 fail:
39482 return NULL;
39483 }
39484
39485
39486 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39487 PyObject *resultobj = 0;
39488 wxWindow *arg1 = (wxWindow *) 0 ;
39489 wxMenu *arg2 = (wxMenu *) 0 ;
39490 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39491 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39492 bool result;
39493 void *argp1 = 0 ;
39494 int res1 = 0 ;
39495 void *argp2 = 0 ;
39496 int res2 = 0 ;
39497 wxPoint temp3 ;
39498 PyObject * obj0 = 0 ;
39499 PyObject * obj1 = 0 ;
39500 PyObject * obj2 = 0 ;
39501 char * kwnames[] = {
39502 (char *) "self",(char *) "menu",(char *) "pos", NULL
39503 };
39504
39505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39507 if (!SWIG_IsOK(res1)) {
39508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39509 }
39510 arg1 = reinterpret_cast< wxWindow * >(argp1);
39511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39512 if (!SWIG_IsOK(res2)) {
39513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39514 }
39515 arg2 = reinterpret_cast< wxMenu * >(argp2);
39516 if (obj2) {
39517 {
39518 arg3 = &temp3;
39519 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39520 }
39521 }
39522 {
39523 PyThreadState* __tstate = wxPyBeginAllowThreads();
39524 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39525 wxPyEndAllowThreads(__tstate);
39526 if (PyErr_Occurred()) SWIG_fail;
39527 }
39528 {
39529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39530 }
39531 return resultobj;
39532 fail:
39533 return NULL;
39534 }
39535
39536
39537 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39538 PyObject *resultobj = 0;
39539 wxWindow *arg1 = (wxWindow *) 0 ;
39540 bool result;
39541 void *argp1 = 0 ;
39542 int res1 = 0 ;
39543 PyObject *swig_obj[1] ;
39544
39545 if (!args) SWIG_fail;
39546 swig_obj[0] = args;
39547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39548 if (!SWIG_IsOK(res1)) {
39549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39550 }
39551 arg1 = reinterpret_cast< wxWindow * >(argp1);
39552 {
39553 PyThreadState* __tstate = wxPyBeginAllowThreads();
39554 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39555 wxPyEndAllowThreads(__tstate);
39556 if (PyErr_Occurred()) SWIG_fail;
39557 }
39558 {
39559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39560 }
39561 return resultobj;
39562 fail:
39563 return NULL;
39564 }
39565
39566
39567 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39568 PyObject *resultobj = 0;
39569 wxWindow *arg1 = (wxWindow *) 0 ;
39570 long result;
39571 void *argp1 = 0 ;
39572 int res1 = 0 ;
39573 PyObject *swig_obj[1] ;
39574
39575 if (!args) SWIG_fail;
39576 swig_obj[0] = args;
39577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39578 if (!SWIG_IsOK(res1)) {
39579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39580 }
39581 arg1 = reinterpret_cast< wxWindow * >(argp1);
39582 {
39583 PyThreadState* __tstate = wxPyBeginAllowThreads();
39584 result = (long)wxWindow_GetHandle(arg1);
39585 wxPyEndAllowThreads(__tstate);
39586 if (PyErr_Occurred()) SWIG_fail;
39587 }
39588 resultobj = SWIG_From_long(static_cast< long >(result));
39589 return resultobj;
39590 fail:
39591 return NULL;
39592 }
39593
39594
39595 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39596 PyObject *resultobj = 0;
39597 wxWindow *arg1 = (wxWindow *) 0 ;
39598 long arg2 ;
39599 void *argp1 = 0 ;
39600 int res1 = 0 ;
39601 long val2 ;
39602 int ecode2 = 0 ;
39603 PyObject * obj0 = 0 ;
39604 PyObject * obj1 = 0 ;
39605 char * kwnames[] = {
39606 (char *) "self",(char *) "handle", NULL
39607 };
39608
39609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39611 if (!SWIG_IsOK(res1)) {
39612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39613 }
39614 arg1 = reinterpret_cast< wxWindow * >(argp1);
39615 ecode2 = SWIG_AsVal_long(obj1, &val2);
39616 if (!SWIG_IsOK(ecode2)) {
39617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39618 }
39619 arg2 = static_cast< long >(val2);
39620 {
39621 PyThreadState* __tstate = wxPyBeginAllowThreads();
39622 wxWindow_AssociateHandle(arg1,arg2);
39623 wxPyEndAllowThreads(__tstate);
39624 if (PyErr_Occurred()) SWIG_fail;
39625 }
39626 resultobj = SWIG_Py_Void();
39627 return resultobj;
39628 fail:
39629 return NULL;
39630 }
39631
39632
39633 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39634 PyObject *resultobj = 0;
39635 wxWindow *arg1 = (wxWindow *) 0 ;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 PyObject *swig_obj[1] ;
39639
39640 if (!args) SWIG_fail;
39641 swig_obj[0] = args;
39642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39643 if (!SWIG_IsOK(res1)) {
39644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39645 }
39646 arg1 = reinterpret_cast< wxWindow * >(argp1);
39647 {
39648 PyThreadState* __tstate = wxPyBeginAllowThreads();
39649 (arg1)->DissociateHandle();
39650 wxPyEndAllowThreads(__tstate);
39651 if (PyErr_Occurred()) SWIG_fail;
39652 }
39653 resultobj = SWIG_Py_Void();
39654 return resultobj;
39655 fail:
39656 return NULL;
39657 }
39658
39659
39660 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39661 PyObject *resultobj = 0;
39662 wxWindow *arg1 = (wxWindow *) 0 ;
39663 int arg2 ;
39664 bool result;
39665 void *argp1 = 0 ;
39666 int res1 = 0 ;
39667 int val2 ;
39668 int ecode2 = 0 ;
39669 PyObject * obj0 = 0 ;
39670 PyObject * obj1 = 0 ;
39671 char * kwnames[] = {
39672 (char *) "self",(char *) "orient", NULL
39673 };
39674
39675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39677 if (!SWIG_IsOK(res1)) {
39678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39679 }
39680 arg1 = reinterpret_cast< wxWindow * >(argp1);
39681 ecode2 = SWIG_AsVal_int(obj1, &val2);
39682 if (!SWIG_IsOK(ecode2)) {
39683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39684 }
39685 arg2 = static_cast< int >(val2);
39686 {
39687 PyThreadState* __tstate = wxPyBeginAllowThreads();
39688 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39689 wxPyEndAllowThreads(__tstate);
39690 if (PyErr_Occurred()) SWIG_fail;
39691 }
39692 {
39693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39694 }
39695 return resultobj;
39696 fail:
39697 return NULL;
39698 }
39699
39700
39701 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39702 PyObject *resultobj = 0;
39703 wxWindow *arg1 = (wxWindow *) 0 ;
39704 int arg2 ;
39705 int arg3 ;
39706 int arg4 ;
39707 int arg5 ;
39708 bool arg6 = (bool) true ;
39709 void *argp1 = 0 ;
39710 int res1 = 0 ;
39711 int val2 ;
39712 int ecode2 = 0 ;
39713 int val3 ;
39714 int ecode3 = 0 ;
39715 int val4 ;
39716 int ecode4 = 0 ;
39717 int val5 ;
39718 int ecode5 = 0 ;
39719 bool val6 ;
39720 int ecode6 = 0 ;
39721 PyObject * obj0 = 0 ;
39722 PyObject * obj1 = 0 ;
39723 PyObject * obj2 = 0 ;
39724 PyObject * obj3 = 0 ;
39725 PyObject * obj4 = 0 ;
39726 PyObject * obj5 = 0 ;
39727 char * kwnames[] = {
39728 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39729 };
39730
39731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39733 if (!SWIG_IsOK(res1)) {
39734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39735 }
39736 arg1 = reinterpret_cast< wxWindow * >(argp1);
39737 ecode2 = SWIG_AsVal_int(obj1, &val2);
39738 if (!SWIG_IsOK(ecode2)) {
39739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39740 }
39741 arg2 = static_cast< int >(val2);
39742 ecode3 = SWIG_AsVal_int(obj2, &val3);
39743 if (!SWIG_IsOK(ecode3)) {
39744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39745 }
39746 arg3 = static_cast< int >(val3);
39747 ecode4 = SWIG_AsVal_int(obj3, &val4);
39748 if (!SWIG_IsOK(ecode4)) {
39749 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39750 }
39751 arg4 = static_cast< int >(val4);
39752 ecode5 = SWIG_AsVal_int(obj4, &val5);
39753 if (!SWIG_IsOK(ecode5)) {
39754 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39755 }
39756 arg5 = static_cast< int >(val5);
39757 if (obj5) {
39758 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39759 if (!SWIG_IsOK(ecode6)) {
39760 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39761 }
39762 arg6 = static_cast< bool >(val6);
39763 }
39764 {
39765 PyThreadState* __tstate = wxPyBeginAllowThreads();
39766 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 resultobj = SWIG_Py_Void();
39771 return resultobj;
39772 fail:
39773 return NULL;
39774 }
39775
39776
39777 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39778 PyObject *resultobj = 0;
39779 wxWindow *arg1 = (wxWindow *) 0 ;
39780 int arg2 ;
39781 int arg3 ;
39782 bool arg4 = (bool) true ;
39783 void *argp1 = 0 ;
39784 int res1 = 0 ;
39785 int val2 ;
39786 int ecode2 = 0 ;
39787 int val3 ;
39788 int ecode3 = 0 ;
39789 bool val4 ;
39790 int ecode4 = 0 ;
39791 PyObject * obj0 = 0 ;
39792 PyObject * obj1 = 0 ;
39793 PyObject * obj2 = 0 ;
39794 PyObject * obj3 = 0 ;
39795 char * kwnames[] = {
39796 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39797 };
39798
39799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39801 if (!SWIG_IsOK(res1)) {
39802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39803 }
39804 arg1 = reinterpret_cast< wxWindow * >(argp1);
39805 ecode2 = SWIG_AsVal_int(obj1, &val2);
39806 if (!SWIG_IsOK(ecode2)) {
39807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39808 }
39809 arg2 = static_cast< int >(val2);
39810 ecode3 = SWIG_AsVal_int(obj2, &val3);
39811 if (!SWIG_IsOK(ecode3)) {
39812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39813 }
39814 arg3 = static_cast< int >(val3);
39815 if (obj3) {
39816 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39817 if (!SWIG_IsOK(ecode4)) {
39818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39819 }
39820 arg4 = static_cast< bool >(val4);
39821 }
39822 {
39823 PyThreadState* __tstate = wxPyBeginAllowThreads();
39824 (arg1)->SetScrollPos(arg2,arg3,arg4);
39825 wxPyEndAllowThreads(__tstate);
39826 if (PyErr_Occurred()) SWIG_fail;
39827 }
39828 resultobj = SWIG_Py_Void();
39829 return resultobj;
39830 fail:
39831 return NULL;
39832 }
39833
39834
39835 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39836 PyObject *resultobj = 0;
39837 wxWindow *arg1 = (wxWindow *) 0 ;
39838 int arg2 ;
39839 int result;
39840 void *argp1 = 0 ;
39841 int res1 = 0 ;
39842 int val2 ;
39843 int ecode2 = 0 ;
39844 PyObject * obj0 = 0 ;
39845 PyObject * obj1 = 0 ;
39846 char * kwnames[] = {
39847 (char *) "self",(char *) "orientation", NULL
39848 };
39849
39850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39852 if (!SWIG_IsOK(res1)) {
39853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39854 }
39855 arg1 = reinterpret_cast< wxWindow * >(argp1);
39856 ecode2 = SWIG_AsVal_int(obj1, &val2);
39857 if (!SWIG_IsOK(ecode2)) {
39858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39859 }
39860 arg2 = static_cast< int >(val2);
39861 {
39862 PyThreadState* __tstate = wxPyBeginAllowThreads();
39863 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39864 wxPyEndAllowThreads(__tstate);
39865 if (PyErr_Occurred()) SWIG_fail;
39866 }
39867 resultobj = SWIG_From_int(static_cast< int >(result));
39868 return resultobj;
39869 fail:
39870 return NULL;
39871 }
39872
39873
39874 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39875 PyObject *resultobj = 0;
39876 wxWindow *arg1 = (wxWindow *) 0 ;
39877 int arg2 ;
39878 int result;
39879 void *argp1 = 0 ;
39880 int res1 = 0 ;
39881 int val2 ;
39882 int ecode2 = 0 ;
39883 PyObject * obj0 = 0 ;
39884 PyObject * obj1 = 0 ;
39885 char * kwnames[] = {
39886 (char *) "self",(char *) "orientation", NULL
39887 };
39888
39889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39891 if (!SWIG_IsOK(res1)) {
39892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39893 }
39894 arg1 = reinterpret_cast< wxWindow * >(argp1);
39895 ecode2 = SWIG_AsVal_int(obj1, &val2);
39896 if (!SWIG_IsOK(ecode2)) {
39897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39898 }
39899 arg2 = static_cast< int >(val2);
39900 {
39901 PyThreadState* __tstate = wxPyBeginAllowThreads();
39902 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39903 wxPyEndAllowThreads(__tstate);
39904 if (PyErr_Occurred()) SWIG_fail;
39905 }
39906 resultobj = SWIG_From_int(static_cast< int >(result));
39907 return resultobj;
39908 fail:
39909 return NULL;
39910 }
39911
39912
39913 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39914 PyObject *resultobj = 0;
39915 wxWindow *arg1 = (wxWindow *) 0 ;
39916 int arg2 ;
39917 int result;
39918 void *argp1 = 0 ;
39919 int res1 = 0 ;
39920 int val2 ;
39921 int ecode2 = 0 ;
39922 PyObject * obj0 = 0 ;
39923 PyObject * obj1 = 0 ;
39924 char * kwnames[] = {
39925 (char *) "self",(char *) "orientation", NULL
39926 };
39927
39928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39930 if (!SWIG_IsOK(res1)) {
39931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39932 }
39933 arg1 = reinterpret_cast< wxWindow * >(argp1);
39934 ecode2 = SWIG_AsVal_int(obj1, &val2);
39935 if (!SWIG_IsOK(ecode2)) {
39936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39937 }
39938 arg2 = static_cast< int >(val2);
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 resultobj = SWIG_From_int(static_cast< int >(result));
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj = 0;
39954 wxWindow *arg1 = (wxWindow *) 0 ;
39955 int arg2 ;
39956 int arg3 ;
39957 wxRect *arg4 = (wxRect *) NULL ;
39958 void *argp1 = 0 ;
39959 int res1 = 0 ;
39960 int val2 ;
39961 int ecode2 = 0 ;
39962 int val3 ;
39963 int ecode3 = 0 ;
39964 void *argp4 = 0 ;
39965 int res4 = 0 ;
39966 PyObject * obj0 = 0 ;
39967 PyObject * obj1 = 0 ;
39968 PyObject * obj2 = 0 ;
39969 PyObject * obj3 = 0 ;
39970 char * kwnames[] = {
39971 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39972 };
39973
39974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39976 if (!SWIG_IsOK(res1)) {
39977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39978 }
39979 arg1 = reinterpret_cast< wxWindow * >(argp1);
39980 ecode2 = SWIG_AsVal_int(obj1, &val2);
39981 if (!SWIG_IsOK(ecode2)) {
39982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39983 }
39984 arg2 = static_cast< int >(val2);
39985 ecode3 = SWIG_AsVal_int(obj2, &val3);
39986 if (!SWIG_IsOK(ecode3)) {
39987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39988 }
39989 arg3 = static_cast< int >(val3);
39990 if (obj3) {
39991 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39992 if (!SWIG_IsOK(res4)) {
39993 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39994 }
39995 arg4 = reinterpret_cast< wxRect * >(argp4);
39996 }
39997 {
39998 PyThreadState* __tstate = wxPyBeginAllowThreads();
39999 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 resultobj = SWIG_Py_Void();
40004 return resultobj;
40005 fail:
40006 return NULL;
40007 }
40008
40009
40010 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40011 PyObject *resultobj = 0;
40012 wxWindow *arg1 = (wxWindow *) 0 ;
40013 int arg2 ;
40014 bool result;
40015 void *argp1 = 0 ;
40016 int res1 = 0 ;
40017 int val2 ;
40018 int ecode2 = 0 ;
40019 PyObject * obj0 = 0 ;
40020 PyObject * obj1 = 0 ;
40021 char * kwnames[] = {
40022 (char *) "self",(char *) "lines", NULL
40023 };
40024
40025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40027 if (!SWIG_IsOK(res1)) {
40028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40029 }
40030 arg1 = reinterpret_cast< wxWindow * >(argp1);
40031 ecode2 = SWIG_AsVal_int(obj1, &val2);
40032 if (!SWIG_IsOK(ecode2)) {
40033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40034 }
40035 arg2 = static_cast< int >(val2);
40036 {
40037 PyThreadState* __tstate = wxPyBeginAllowThreads();
40038 result = (bool)(arg1)->ScrollLines(arg2);
40039 wxPyEndAllowThreads(__tstate);
40040 if (PyErr_Occurred()) SWIG_fail;
40041 }
40042 {
40043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40044 }
40045 return resultobj;
40046 fail:
40047 return NULL;
40048 }
40049
40050
40051 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40052 PyObject *resultobj = 0;
40053 wxWindow *arg1 = (wxWindow *) 0 ;
40054 int arg2 ;
40055 bool result;
40056 void *argp1 = 0 ;
40057 int res1 = 0 ;
40058 int val2 ;
40059 int ecode2 = 0 ;
40060 PyObject * obj0 = 0 ;
40061 PyObject * obj1 = 0 ;
40062 char * kwnames[] = {
40063 (char *) "self",(char *) "pages", NULL
40064 };
40065
40066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40068 if (!SWIG_IsOK(res1)) {
40069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40070 }
40071 arg1 = reinterpret_cast< wxWindow * >(argp1);
40072 ecode2 = SWIG_AsVal_int(obj1, &val2);
40073 if (!SWIG_IsOK(ecode2)) {
40074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40075 }
40076 arg2 = static_cast< int >(val2);
40077 {
40078 PyThreadState* __tstate = wxPyBeginAllowThreads();
40079 result = (bool)(arg1)->ScrollPages(arg2);
40080 wxPyEndAllowThreads(__tstate);
40081 if (PyErr_Occurred()) SWIG_fail;
40082 }
40083 {
40084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40085 }
40086 return resultobj;
40087 fail:
40088 return NULL;
40089 }
40090
40091
40092 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40093 PyObject *resultobj = 0;
40094 wxWindow *arg1 = (wxWindow *) 0 ;
40095 bool result;
40096 void *argp1 = 0 ;
40097 int res1 = 0 ;
40098 PyObject *swig_obj[1] ;
40099
40100 if (!args) SWIG_fail;
40101 swig_obj[0] = args;
40102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40103 if (!SWIG_IsOK(res1)) {
40104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40105 }
40106 arg1 = reinterpret_cast< wxWindow * >(argp1);
40107 {
40108 PyThreadState* __tstate = wxPyBeginAllowThreads();
40109 result = (bool)(arg1)->LineUp();
40110 wxPyEndAllowThreads(__tstate);
40111 if (PyErr_Occurred()) SWIG_fail;
40112 }
40113 {
40114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40115 }
40116 return resultobj;
40117 fail:
40118 return NULL;
40119 }
40120
40121
40122 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40123 PyObject *resultobj = 0;
40124 wxWindow *arg1 = (wxWindow *) 0 ;
40125 bool result;
40126 void *argp1 = 0 ;
40127 int res1 = 0 ;
40128 PyObject *swig_obj[1] ;
40129
40130 if (!args) SWIG_fail;
40131 swig_obj[0] = args;
40132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40133 if (!SWIG_IsOK(res1)) {
40134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40135 }
40136 arg1 = reinterpret_cast< wxWindow * >(argp1);
40137 {
40138 PyThreadState* __tstate = wxPyBeginAllowThreads();
40139 result = (bool)(arg1)->LineDown();
40140 wxPyEndAllowThreads(__tstate);
40141 if (PyErr_Occurred()) SWIG_fail;
40142 }
40143 {
40144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40145 }
40146 return resultobj;
40147 fail:
40148 return NULL;
40149 }
40150
40151
40152 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40153 PyObject *resultobj = 0;
40154 wxWindow *arg1 = (wxWindow *) 0 ;
40155 bool result;
40156 void *argp1 = 0 ;
40157 int res1 = 0 ;
40158 PyObject *swig_obj[1] ;
40159
40160 if (!args) SWIG_fail;
40161 swig_obj[0] = args;
40162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40163 if (!SWIG_IsOK(res1)) {
40164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40165 }
40166 arg1 = reinterpret_cast< wxWindow * >(argp1);
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 result = (bool)(arg1)->PageUp();
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 {
40174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40175 }
40176 return resultobj;
40177 fail:
40178 return NULL;
40179 }
40180
40181
40182 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40183 PyObject *resultobj = 0;
40184 wxWindow *arg1 = (wxWindow *) 0 ;
40185 bool result;
40186 void *argp1 = 0 ;
40187 int res1 = 0 ;
40188 PyObject *swig_obj[1] ;
40189
40190 if (!args) SWIG_fail;
40191 swig_obj[0] = args;
40192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40193 if (!SWIG_IsOK(res1)) {
40194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40195 }
40196 arg1 = reinterpret_cast< wxWindow * >(argp1);
40197 {
40198 PyThreadState* __tstate = wxPyBeginAllowThreads();
40199 result = (bool)(arg1)->PageDown();
40200 wxPyEndAllowThreads(__tstate);
40201 if (PyErr_Occurred()) SWIG_fail;
40202 }
40203 {
40204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40205 }
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40213 PyObject *resultobj = 0;
40214 wxWindow *arg1 = (wxWindow *) 0 ;
40215 wxString *arg2 = 0 ;
40216 void *argp1 = 0 ;
40217 int res1 = 0 ;
40218 bool temp2 = false ;
40219 PyObject * obj0 = 0 ;
40220 PyObject * obj1 = 0 ;
40221 char * kwnames[] = {
40222 (char *) "self",(char *) "text", NULL
40223 };
40224
40225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40227 if (!SWIG_IsOK(res1)) {
40228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40229 }
40230 arg1 = reinterpret_cast< wxWindow * >(argp1);
40231 {
40232 arg2 = wxString_in_helper(obj1);
40233 if (arg2 == NULL) SWIG_fail;
40234 temp2 = true;
40235 }
40236 {
40237 PyThreadState* __tstate = wxPyBeginAllowThreads();
40238 (arg1)->SetHelpText((wxString const &)*arg2);
40239 wxPyEndAllowThreads(__tstate);
40240 if (PyErr_Occurred()) SWIG_fail;
40241 }
40242 resultobj = SWIG_Py_Void();
40243 {
40244 if (temp2)
40245 delete arg2;
40246 }
40247 return resultobj;
40248 fail:
40249 {
40250 if (temp2)
40251 delete arg2;
40252 }
40253 return NULL;
40254 }
40255
40256
40257 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40258 PyObject *resultobj = 0;
40259 wxWindow *arg1 = (wxWindow *) 0 ;
40260 wxString *arg2 = 0 ;
40261 void *argp1 = 0 ;
40262 int res1 = 0 ;
40263 bool temp2 = false ;
40264 PyObject * obj0 = 0 ;
40265 PyObject * obj1 = 0 ;
40266 char * kwnames[] = {
40267 (char *) "self",(char *) "text", NULL
40268 };
40269
40270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40272 if (!SWIG_IsOK(res1)) {
40273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40274 }
40275 arg1 = reinterpret_cast< wxWindow * >(argp1);
40276 {
40277 arg2 = wxString_in_helper(obj1);
40278 if (arg2 == NULL) SWIG_fail;
40279 temp2 = true;
40280 }
40281 {
40282 PyThreadState* __tstate = wxPyBeginAllowThreads();
40283 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40284 wxPyEndAllowThreads(__tstate);
40285 if (PyErr_Occurred()) SWIG_fail;
40286 }
40287 resultobj = SWIG_Py_Void();
40288 {
40289 if (temp2)
40290 delete arg2;
40291 }
40292 return resultobj;
40293 fail:
40294 {
40295 if (temp2)
40296 delete arg2;
40297 }
40298 return NULL;
40299 }
40300
40301
40302 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40303 PyObject *resultobj = 0;
40304 wxWindow *arg1 = (wxWindow *) 0 ;
40305 wxPoint *arg2 = 0 ;
40306 wxHelpEvent::Origin arg3 ;
40307 wxString result;
40308 void *argp1 = 0 ;
40309 int res1 = 0 ;
40310 wxPoint temp2 ;
40311 void *argp3 ;
40312 int res3 = 0 ;
40313 PyObject * obj0 = 0 ;
40314 PyObject * obj1 = 0 ;
40315 PyObject * obj2 = 0 ;
40316 char * kwnames[] = {
40317 (char *) "self",(char *) "pt",(char *) "origin", NULL
40318 };
40319
40320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40322 if (!SWIG_IsOK(res1)) {
40323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40324 }
40325 arg1 = reinterpret_cast< wxWindow * >(argp1);
40326 {
40327 arg2 = &temp2;
40328 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40329 }
40330 {
40331 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40332 if (!SWIG_IsOK(res3)) {
40333 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40334 }
40335 if (!argp3) {
40336 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40337 } else {
40338 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40339 arg3 = *temp;
40340 if (SWIG_IsNewObj(res3)) delete temp;
40341 }
40342 }
40343 {
40344 PyThreadState* __tstate = wxPyBeginAllowThreads();
40345 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40346 wxPyEndAllowThreads(__tstate);
40347 if (PyErr_Occurred()) SWIG_fail;
40348 }
40349 {
40350 #if wxUSE_UNICODE
40351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40352 #else
40353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40354 #endif
40355 }
40356 return resultobj;
40357 fail:
40358 return NULL;
40359 }
40360
40361
40362 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40363 PyObject *resultobj = 0;
40364 wxWindow *arg1 = (wxWindow *) 0 ;
40365 wxString result;
40366 void *argp1 = 0 ;
40367 int res1 = 0 ;
40368 PyObject *swig_obj[1] ;
40369
40370 if (!args) SWIG_fail;
40371 swig_obj[0] = args;
40372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40373 if (!SWIG_IsOK(res1)) {
40374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40375 }
40376 arg1 = reinterpret_cast< wxWindow * >(argp1);
40377 {
40378 PyThreadState* __tstate = wxPyBeginAllowThreads();
40379 result = ((wxWindow const *)arg1)->GetHelpText();
40380 wxPyEndAllowThreads(__tstate);
40381 if (PyErr_Occurred()) SWIG_fail;
40382 }
40383 {
40384 #if wxUSE_UNICODE
40385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40386 #else
40387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40388 #endif
40389 }
40390 return resultobj;
40391 fail:
40392 return NULL;
40393 }
40394
40395
40396 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40397 PyObject *resultobj = 0;
40398 wxWindow *arg1 = (wxWindow *) 0 ;
40399 wxString *arg2 = 0 ;
40400 void *argp1 = 0 ;
40401 int res1 = 0 ;
40402 bool temp2 = false ;
40403 PyObject * obj0 = 0 ;
40404 PyObject * obj1 = 0 ;
40405 char * kwnames[] = {
40406 (char *) "self",(char *) "tip", NULL
40407 };
40408
40409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40411 if (!SWIG_IsOK(res1)) {
40412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40413 }
40414 arg1 = reinterpret_cast< wxWindow * >(argp1);
40415 {
40416 arg2 = wxString_in_helper(obj1);
40417 if (arg2 == NULL) SWIG_fail;
40418 temp2 = true;
40419 }
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 (arg1)->SetToolTip((wxString const &)*arg2);
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 resultobj = SWIG_Py_Void();
40427 {
40428 if (temp2)
40429 delete arg2;
40430 }
40431 return resultobj;
40432 fail:
40433 {
40434 if (temp2)
40435 delete arg2;
40436 }
40437 return NULL;
40438 }
40439
40440
40441 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40442 PyObject *resultobj = 0;
40443 wxWindow *arg1 = (wxWindow *) 0 ;
40444 wxToolTip *arg2 = (wxToolTip *) 0 ;
40445 void *argp1 = 0 ;
40446 int res1 = 0 ;
40447 int res2 = 0 ;
40448 PyObject * obj0 = 0 ;
40449 PyObject * obj1 = 0 ;
40450 char * kwnames[] = {
40451 (char *) "self",(char *) "tip", NULL
40452 };
40453
40454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40456 if (!SWIG_IsOK(res1)) {
40457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40458 }
40459 arg1 = reinterpret_cast< wxWindow * >(argp1);
40460 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40461 if (!SWIG_IsOK(res2)) {
40462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40463 }
40464 {
40465 PyThreadState* __tstate = wxPyBeginAllowThreads();
40466 (arg1)->SetToolTip(arg2);
40467 wxPyEndAllowThreads(__tstate);
40468 if (PyErr_Occurred()) SWIG_fail;
40469 }
40470 resultobj = SWIG_Py_Void();
40471 return resultobj;
40472 fail:
40473 return NULL;
40474 }
40475
40476
40477 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40478 PyObject *resultobj = 0;
40479 wxWindow *arg1 = (wxWindow *) 0 ;
40480 wxToolTip *result = 0 ;
40481 void *argp1 = 0 ;
40482 int res1 = 0 ;
40483 PyObject *swig_obj[1] ;
40484
40485 if (!args) SWIG_fail;
40486 swig_obj[0] = args;
40487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40488 if (!SWIG_IsOK(res1)) {
40489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40490 }
40491 arg1 = reinterpret_cast< wxWindow * >(argp1);
40492 {
40493 PyThreadState* __tstate = wxPyBeginAllowThreads();
40494 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40495 wxPyEndAllowThreads(__tstate);
40496 if (PyErr_Occurred()) SWIG_fail;
40497 }
40498 {
40499 resultobj = wxPyMake_wxObject(result, (bool)0);
40500 }
40501 return resultobj;
40502 fail:
40503 return NULL;
40504 }
40505
40506
40507 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40508 PyObject *resultobj = 0;
40509 wxWindow *arg1 = (wxWindow *) 0 ;
40510 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40511 void *argp1 = 0 ;
40512 int res1 = 0 ;
40513 int res2 = 0 ;
40514 PyObject * obj0 = 0 ;
40515 PyObject * obj1 = 0 ;
40516 char * kwnames[] = {
40517 (char *) "self",(char *) "dropTarget", NULL
40518 };
40519
40520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40522 if (!SWIG_IsOK(res1)) {
40523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40524 }
40525 arg1 = reinterpret_cast< wxWindow * >(argp1);
40526 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40527 if (!SWIG_IsOK(res2)) {
40528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40529 }
40530 {
40531 PyThreadState* __tstate = wxPyBeginAllowThreads();
40532 (arg1)->SetDropTarget(arg2);
40533 wxPyEndAllowThreads(__tstate);
40534 if (PyErr_Occurred()) SWIG_fail;
40535 }
40536 resultobj = SWIG_Py_Void();
40537 return resultobj;
40538 fail:
40539 return NULL;
40540 }
40541
40542
40543 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40544 PyObject *resultobj = 0;
40545 wxWindow *arg1 = (wxWindow *) 0 ;
40546 wxPyDropTarget *result = 0 ;
40547 void *argp1 = 0 ;
40548 int res1 = 0 ;
40549 PyObject *swig_obj[1] ;
40550
40551 if (!args) SWIG_fail;
40552 swig_obj[0] = args;
40553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40554 if (!SWIG_IsOK(res1)) {
40555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40556 }
40557 arg1 = reinterpret_cast< wxWindow * >(argp1);
40558 {
40559 PyThreadState* __tstate = wxPyBeginAllowThreads();
40560 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40565 return resultobj;
40566 fail:
40567 return NULL;
40568 }
40569
40570
40571 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40572 PyObject *resultobj = 0;
40573 wxWindow *arg1 = (wxWindow *) 0 ;
40574 bool arg2 ;
40575 void *argp1 = 0 ;
40576 int res1 = 0 ;
40577 bool val2 ;
40578 int ecode2 = 0 ;
40579 PyObject * obj0 = 0 ;
40580 PyObject * obj1 = 0 ;
40581 char * kwnames[] = {
40582 (char *) "self",(char *) "accept", NULL
40583 };
40584
40585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40587 if (!SWIG_IsOK(res1)) {
40588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40589 }
40590 arg1 = reinterpret_cast< wxWindow * >(argp1);
40591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40592 if (!SWIG_IsOK(ecode2)) {
40593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40594 }
40595 arg2 = static_cast< bool >(val2);
40596 {
40597 PyThreadState* __tstate = wxPyBeginAllowThreads();
40598 wxWindow_DragAcceptFiles(arg1,arg2);
40599 wxPyEndAllowThreads(__tstate);
40600 if (PyErr_Occurred()) SWIG_fail;
40601 }
40602 resultobj = SWIG_Py_Void();
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj = 0;
40611 wxWindow *arg1 = (wxWindow *) 0 ;
40612 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40613 void *argp1 = 0 ;
40614 int res1 = 0 ;
40615 int res2 = 0 ;
40616 PyObject * obj0 = 0 ;
40617 PyObject * obj1 = 0 ;
40618 char * kwnames[] = {
40619 (char *) "self",(char *) "constraints", NULL
40620 };
40621
40622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40624 if (!SWIG_IsOK(res1)) {
40625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40626 }
40627 arg1 = reinterpret_cast< wxWindow * >(argp1);
40628 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40629 if (!SWIG_IsOK(res2)) {
40630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40631 }
40632 {
40633 PyThreadState* __tstate = wxPyBeginAllowThreads();
40634 (arg1)->SetConstraints(arg2);
40635 wxPyEndAllowThreads(__tstate);
40636 if (PyErr_Occurred()) SWIG_fail;
40637 }
40638 resultobj = SWIG_Py_Void();
40639 return resultobj;
40640 fail:
40641 return NULL;
40642 }
40643
40644
40645 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40646 PyObject *resultobj = 0;
40647 wxWindow *arg1 = (wxWindow *) 0 ;
40648 wxLayoutConstraints *result = 0 ;
40649 void *argp1 = 0 ;
40650 int res1 = 0 ;
40651 PyObject *swig_obj[1] ;
40652
40653 if (!args) SWIG_fail;
40654 swig_obj[0] = args;
40655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40656 if (!SWIG_IsOK(res1)) {
40657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40658 }
40659 arg1 = reinterpret_cast< wxWindow * >(argp1);
40660 {
40661 PyThreadState* __tstate = wxPyBeginAllowThreads();
40662 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40663 wxPyEndAllowThreads(__tstate);
40664 if (PyErr_Occurred()) SWIG_fail;
40665 }
40666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40667 return resultobj;
40668 fail:
40669 return NULL;
40670 }
40671
40672
40673 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40674 PyObject *resultobj = 0;
40675 wxWindow *arg1 = (wxWindow *) 0 ;
40676 bool arg2 ;
40677 void *argp1 = 0 ;
40678 int res1 = 0 ;
40679 bool val2 ;
40680 int ecode2 = 0 ;
40681 PyObject * obj0 = 0 ;
40682 PyObject * obj1 = 0 ;
40683 char * kwnames[] = {
40684 (char *) "self",(char *) "autoLayout", NULL
40685 };
40686
40687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40689 if (!SWIG_IsOK(res1)) {
40690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40691 }
40692 arg1 = reinterpret_cast< wxWindow * >(argp1);
40693 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40694 if (!SWIG_IsOK(ecode2)) {
40695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40696 }
40697 arg2 = static_cast< bool >(val2);
40698 {
40699 PyThreadState* __tstate = wxPyBeginAllowThreads();
40700 (arg1)->SetAutoLayout(arg2);
40701 wxPyEndAllowThreads(__tstate);
40702 if (PyErr_Occurred()) SWIG_fail;
40703 }
40704 resultobj = SWIG_Py_Void();
40705 return resultobj;
40706 fail:
40707 return NULL;
40708 }
40709
40710
40711 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40712 PyObject *resultobj = 0;
40713 wxWindow *arg1 = (wxWindow *) 0 ;
40714 bool result;
40715 void *argp1 = 0 ;
40716 int res1 = 0 ;
40717 PyObject *swig_obj[1] ;
40718
40719 if (!args) SWIG_fail;
40720 swig_obj[0] = args;
40721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40722 if (!SWIG_IsOK(res1)) {
40723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40724 }
40725 arg1 = reinterpret_cast< wxWindow * >(argp1);
40726 {
40727 PyThreadState* __tstate = wxPyBeginAllowThreads();
40728 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40729 wxPyEndAllowThreads(__tstate);
40730 if (PyErr_Occurred()) SWIG_fail;
40731 }
40732 {
40733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40734 }
40735 return resultobj;
40736 fail:
40737 return NULL;
40738 }
40739
40740
40741 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40742 PyObject *resultobj = 0;
40743 wxWindow *arg1 = (wxWindow *) 0 ;
40744 bool result;
40745 void *argp1 = 0 ;
40746 int res1 = 0 ;
40747 PyObject *swig_obj[1] ;
40748
40749 if (!args) SWIG_fail;
40750 swig_obj[0] = args;
40751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40752 if (!SWIG_IsOK(res1)) {
40753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40754 }
40755 arg1 = reinterpret_cast< wxWindow * >(argp1);
40756 {
40757 PyThreadState* __tstate = wxPyBeginAllowThreads();
40758 result = (bool)(arg1)->Layout();
40759 wxPyEndAllowThreads(__tstate);
40760 if (PyErr_Occurred()) SWIG_fail;
40761 }
40762 {
40763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40764 }
40765 return resultobj;
40766 fail:
40767 return NULL;
40768 }
40769
40770
40771 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40772 PyObject *resultobj = 0;
40773 wxWindow *arg1 = (wxWindow *) 0 ;
40774 wxSizer *arg2 = (wxSizer *) 0 ;
40775 bool arg3 = (bool) true ;
40776 void *argp1 = 0 ;
40777 int res1 = 0 ;
40778 int res2 = 0 ;
40779 bool val3 ;
40780 int ecode3 = 0 ;
40781 PyObject * obj0 = 0 ;
40782 PyObject * obj1 = 0 ;
40783 PyObject * obj2 = 0 ;
40784 char * kwnames[] = {
40785 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40786 };
40787
40788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40790 if (!SWIG_IsOK(res1)) {
40791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40792 }
40793 arg1 = reinterpret_cast< wxWindow * >(argp1);
40794 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40795 if (!SWIG_IsOK(res2)) {
40796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40797 }
40798 if (obj2) {
40799 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40800 if (!SWIG_IsOK(ecode3)) {
40801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40802 }
40803 arg3 = static_cast< bool >(val3);
40804 }
40805 {
40806 PyThreadState* __tstate = wxPyBeginAllowThreads();
40807 (arg1)->SetSizer(arg2,arg3);
40808 wxPyEndAllowThreads(__tstate);
40809 if (PyErr_Occurred()) SWIG_fail;
40810 }
40811 resultobj = SWIG_Py_Void();
40812 return resultobj;
40813 fail:
40814 return NULL;
40815 }
40816
40817
40818 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40819 PyObject *resultobj = 0;
40820 wxWindow *arg1 = (wxWindow *) 0 ;
40821 wxSizer *arg2 = (wxSizer *) 0 ;
40822 bool arg3 = (bool) true ;
40823 void *argp1 = 0 ;
40824 int res1 = 0 ;
40825 int res2 = 0 ;
40826 bool val3 ;
40827 int ecode3 = 0 ;
40828 PyObject * obj0 = 0 ;
40829 PyObject * obj1 = 0 ;
40830 PyObject * obj2 = 0 ;
40831 char * kwnames[] = {
40832 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40833 };
40834
40835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40837 if (!SWIG_IsOK(res1)) {
40838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40839 }
40840 arg1 = reinterpret_cast< wxWindow * >(argp1);
40841 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40842 if (!SWIG_IsOK(res2)) {
40843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40844 }
40845 if (obj2) {
40846 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40847 if (!SWIG_IsOK(ecode3)) {
40848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40849 }
40850 arg3 = static_cast< bool >(val3);
40851 }
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 (arg1)->SetSizerAndFit(arg2,arg3);
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 resultobj = SWIG_Py_Void();
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40866 PyObject *resultobj = 0;
40867 wxWindow *arg1 = (wxWindow *) 0 ;
40868 wxSizer *result = 0 ;
40869 void *argp1 = 0 ;
40870 int res1 = 0 ;
40871 PyObject *swig_obj[1] ;
40872
40873 if (!args) SWIG_fail;
40874 swig_obj[0] = args;
40875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40876 if (!SWIG_IsOK(res1)) {
40877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40878 }
40879 arg1 = reinterpret_cast< wxWindow * >(argp1);
40880 {
40881 PyThreadState* __tstate = wxPyBeginAllowThreads();
40882 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40883 wxPyEndAllowThreads(__tstate);
40884 if (PyErr_Occurred()) SWIG_fail;
40885 }
40886 {
40887 resultobj = wxPyMake_wxObject(result, (bool)0);
40888 }
40889 return resultobj;
40890 fail:
40891 return NULL;
40892 }
40893
40894
40895 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40896 PyObject *resultobj = 0;
40897 wxWindow *arg1 = (wxWindow *) 0 ;
40898 wxSizer *arg2 = (wxSizer *) 0 ;
40899 void *argp1 = 0 ;
40900 int res1 = 0 ;
40901 void *argp2 = 0 ;
40902 int res2 = 0 ;
40903 PyObject * obj0 = 0 ;
40904 PyObject * obj1 = 0 ;
40905 char * kwnames[] = {
40906 (char *) "self",(char *) "sizer", NULL
40907 };
40908
40909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40911 if (!SWIG_IsOK(res1)) {
40912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40913 }
40914 arg1 = reinterpret_cast< wxWindow * >(argp1);
40915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40916 if (!SWIG_IsOK(res2)) {
40917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40918 }
40919 arg2 = reinterpret_cast< wxSizer * >(argp2);
40920 {
40921 PyThreadState* __tstate = wxPyBeginAllowThreads();
40922 (arg1)->SetContainingSizer(arg2);
40923 wxPyEndAllowThreads(__tstate);
40924 if (PyErr_Occurred()) SWIG_fail;
40925 }
40926 resultobj = SWIG_Py_Void();
40927 return resultobj;
40928 fail:
40929 return NULL;
40930 }
40931
40932
40933 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40934 PyObject *resultobj = 0;
40935 wxWindow *arg1 = (wxWindow *) 0 ;
40936 wxSizer *result = 0 ;
40937 void *argp1 = 0 ;
40938 int res1 = 0 ;
40939 PyObject *swig_obj[1] ;
40940
40941 if (!args) SWIG_fail;
40942 swig_obj[0] = args;
40943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40944 if (!SWIG_IsOK(res1)) {
40945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40946 }
40947 arg1 = reinterpret_cast< wxWindow * >(argp1);
40948 {
40949 PyThreadState* __tstate = wxPyBeginAllowThreads();
40950 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40951 wxPyEndAllowThreads(__tstate);
40952 if (PyErr_Occurred()) SWIG_fail;
40953 }
40954 {
40955 resultobj = wxPyMake_wxObject(result, (bool)0);
40956 }
40957 return resultobj;
40958 fail:
40959 return NULL;
40960 }
40961
40962
40963 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40964 PyObject *resultobj = 0;
40965 wxWindow *arg1 = (wxWindow *) 0 ;
40966 void *argp1 = 0 ;
40967 int res1 = 0 ;
40968 PyObject *swig_obj[1] ;
40969
40970 if (!args) SWIG_fail;
40971 swig_obj[0] = args;
40972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40973 if (!SWIG_IsOK(res1)) {
40974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40975 }
40976 arg1 = reinterpret_cast< wxWindow * >(argp1);
40977 {
40978 PyThreadState* __tstate = wxPyBeginAllowThreads();
40979 (arg1)->InheritAttributes();
40980 wxPyEndAllowThreads(__tstate);
40981 if (PyErr_Occurred()) SWIG_fail;
40982 }
40983 resultobj = SWIG_Py_Void();
40984 return resultobj;
40985 fail:
40986 return NULL;
40987 }
40988
40989
40990 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40991 PyObject *resultobj = 0;
40992 wxWindow *arg1 = (wxWindow *) 0 ;
40993 bool result;
40994 void *argp1 = 0 ;
40995 int res1 = 0 ;
40996 PyObject *swig_obj[1] ;
40997
40998 if (!args) SWIG_fail;
40999 swig_obj[0] = args;
41000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41001 if (!SWIG_IsOK(res1)) {
41002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41003 }
41004 arg1 = reinterpret_cast< wxWindow * >(argp1);
41005 {
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41008 wxPyEndAllowThreads(__tstate);
41009 if (PyErr_Occurred()) SWIG_fail;
41010 }
41011 {
41012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41013 }
41014 return resultobj;
41015 fail:
41016 return NULL;
41017 }
41018
41019
41020 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41021 PyObject *resultobj = 0;
41022 wxWindow *arg1 = (wxWindow *) 0 ;
41023 bool result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 PyObject *swig_obj[1] ;
41027
41028 if (!args) SWIG_fail;
41029 swig_obj[0] = args;
41030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41031 if (!SWIG_IsOK(res1)) {
41032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41033 }
41034 arg1 = reinterpret_cast< wxWindow * >(argp1);
41035 {
41036 PyThreadState* __tstate = wxPyBeginAllowThreads();
41037 result = (bool)(arg1)->CanSetTransparent();
41038 wxPyEndAllowThreads(__tstate);
41039 if (PyErr_Occurred()) SWIG_fail;
41040 }
41041 {
41042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41043 }
41044 return resultobj;
41045 fail:
41046 return NULL;
41047 }
41048
41049
41050 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41051 PyObject *resultobj = 0;
41052 wxWindow *arg1 = (wxWindow *) 0 ;
41053 byte arg2 ;
41054 bool result;
41055 void *argp1 = 0 ;
41056 int res1 = 0 ;
41057 unsigned char val2 ;
41058 int ecode2 = 0 ;
41059 PyObject * obj0 = 0 ;
41060 PyObject * obj1 = 0 ;
41061 char * kwnames[] = {
41062 (char *) "self",(char *) "alpha", NULL
41063 };
41064
41065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41067 if (!SWIG_IsOK(res1)) {
41068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41069 }
41070 arg1 = reinterpret_cast< wxWindow * >(argp1);
41071 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41072 if (!SWIG_IsOK(ecode2)) {
41073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41074 }
41075 arg2 = static_cast< byte >(val2);
41076 {
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 result = (bool)(arg1)->SetTransparent(arg2);
41079 wxPyEndAllowThreads(__tstate);
41080 if (PyErr_Occurred()) SWIG_fail;
41081 }
41082 {
41083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41084 }
41085 return resultobj;
41086 fail:
41087 return NULL;
41088 }
41089
41090
41091 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41092 PyObject *obj;
41093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41094 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41095 return SWIG_Py_Void();
41096 }
41097
41098 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41099 return SWIG_Python_InitShadowInstance(args);
41100 }
41101
41102 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41103 PyObject *resultobj = 0;
41104 long arg1 ;
41105 wxWindow *arg2 = (wxWindow *) NULL ;
41106 wxWindow *result = 0 ;
41107 long val1 ;
41108 int ecode1 = 0 ;
41109 void *argp2 = 0 ;
41110 int res2 = 0 ;
41111 PyObject * obj0 = 0 ;
41112 PyObject * obj1 = 0 ;
41113 char * kwnames[] = {
41114 (char *) "id",(char *) "parent", NULL
41115 };
41116
41117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41118 ecode1 = SWIG_AsVal_long(obj0, &val1);
41119 if (!SWIG_IsOK(ecode1)) {
41120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41121 }
41122 arg1 = static_cast< long >(val1);
41123 if (obj1) {
41124 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41125 if (!SWIG_IsOK(res2)) {
41126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41127 }
41128 arg2 = reinterpret_cast< wxWindow * >(argp2);
41129 }
41130 {
41131 if (!wxPyCheckForApp()) SWIG_fail;
41132 PyThreadState* __tstate = wxPyBeginAllowThreads();
41133 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41134 wxPyEndAllowThreads(__tstate);
41135 if (PyErr_Occurred()) SWIG_fail;
41136 }
41137 {
41138 resultobj = wxPyMake_wxObject(result, 0);
41139 }
41140 return resultobj;
41141 fail:
41142 return NULL;
41143 }
41144
41145
41146 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41147 PyObject *resultobj = 0;
41148 wxString *arg1 = 0 ;
41149 wxWindow *arg2 = (wxWindow *) NULL ;
41150 wxWindow *result = 0 ;
41151 bool temp1 = false ;
41152 void *argp2 = 0 ;
41153 int res2 = 0 ;
41154 PyObject * obj0 = 0 ;
41155 PyObject * obj1 = 0 ;
41156 char * kwnames[] = {
41157 (char *) "name",(char *) "parent", NULL
41158 };
41159
41160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41161 {
41162 arg1 = wxString_in_helper(obj0);
41163 if (arg1 == NULL) SWIG_fail;
41164 temp1 = true;
41165 }
41166 if (obj1) {
41167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41168 if (!SWIG_IsOK(res2)) {
41169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41170 }
41171 arg2 = reinterpret_cast< wxWindow * >(argp2);
41172 }
41173 {
41174 if (!wxPyCheckForApp()) SWIG_fail;
41175 PyThreadState* __tstate = wxPyBeginAllowThreads();
41176 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41177 wxPyEndAllowThreads(__tstate);
41178 if (PyErr_Occurred()) SWIG_fail;
41179 }
41180 {
41181 resultobj = wxPyMake_wxObject(result, 0);
41182 }
41183 {
41184 if (temp1)
41185 delete arg1;
41186 }
41187 return resultobj;
41188 fail:
41189 {
41190 if (temp1)
41191 delete arg1;
41192 }
41193 return NULL;
41194 }
41195
41196
41197 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41198 PyObject *resultobj = 0;
41199 wxString *arg1 = 0 ;
41200 wxWindow *arg2 = (wxWindow *) NULL ;
41201 wxWindow *result = 0 ;
41202 bool temp1 = false ;
41203 void *argp2 = 0 ;
41204 int res2 = 0 ;
41205 PyObject * obj0 = 0 ;
41206 PyObject * obj1 = 0 ;
41207 char * kwnames[] = {
41208 (char *) "label",(char *) "parent", NULL
41209 };
41210
41211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41212 {
41213 arg1 = wxString_in_helper(obj0);
41214 if (arg1 == NULL) SWIG_fail;
41215 temp1 = true;
41216 }
41217 if (obj1) {
41218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41219 if (!SWIG_IsOK(res2)) {
41220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41221 }
41222 arg2 = reinterpret_cast< wxWindow * >(argp2);
41223 }
41224 {
41225 if (!wxPyCheckForApp()) SWIG_fail;
41226 PyThreadState* __tstate = wxPyBeginAllowThreads();
41227 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41228 wxPyEndAllowThreads(__tstate);
41229 if (PyErr_Occurred()) SWIG_fail;
41230 }
41231 {
41232 resultobj = wxPyMake_wxObject(result, 0);
41233 }
41234 {
41235 if (temp1)
41236 delete arg1;
41237 }
41238 return resultobj;
41239 fail:
41240 {
41241 if (temp1)
41242 delete arg1;
41243 }
41244 return NULL;
41245 }
41246
41247
41248 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41249 PyObject *resultobj = 0;
41250 wxWindow *arg1 = (wxWindow *) 0 ;
41251 unsigned long arg2 ;
41252 wxWindow *result = 0 ;
41253 void *argp1 = 0 ;
41254 int res1 = 0 ;
41255 unsigned long val2 ;
41256 int ecode2 = 0 ;
41257 PyObject * obj0 = 0 ;
41258 PyObject * obj1 = 0 ;
41259 char * kwnames[] = {
41260 (char *) "parent",(char *) "_hWnd", NULL
41261 };
41262
41263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41265 if (!SWIG_IsOK(res1)) {
41266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41267 }
41268 arg1 = reinterpret_cast< wxWindow * >(argp1);
41269 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41270 if (!SWIG_IsOK(ecode2)) {
41271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41272 }
41273 arg2 = static_cast< unsigned long >(val2);
41274 {
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41277 wxPyEndAllowThreads(__tstate);
41278 if (PyErr_Occurred()) SWIG_fail;
41279 }
41280 {
41281 resultobj = wxPyMake_wxObject(result, 0);
41282 }
41283 return resultobj;
41284 fail:
41285 return NULL;
41286 }
41287
41288
41289 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41290 PyObject *resultobj = 0;
41291 PyObject *result = 0 ;
41292
41293 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41294 {
41295 PyThreadState* __tstate = wxPyBeginAllowThreads();
41296 result = (PyObject *)GetTopLevelWindows();
41297 wxPyEndAllowThreads(__tstate);
41298 if (PyErr_Occurred()) SWIG_fail;
41299 }
41300 resultobj = result;
41301 return resultobj;
41302 fail:
41303 return NULL;
41304 }
41305
41306
41307 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41308 PyObject *resultobj = 0;
41309 wxValidator *result = 0 ;
41310
41311 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41312 {
41313 PyThreadState* __tstate = wxPyBeginAllowThreads();
41314 result = (wxValidator *)new wxValidator();
41315 wxPyEndAllowThreads(__tstate);
41316 if (PyErr_Occurred()) SWIG_fail;
41317 }
41318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41319 return resultobj;
41320 fail:
41321 return NULL;
41322 }
41323
41324
41325 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41326 PyObject *resultobj = 0;
41327 wxValidator *arg1 = (wxValidator *) 0 ;
41328 wxValidator *result = 0 ;
41329 void *argp1 = 0 ;
41330 int res1 = 0 ;
41331 PyObject *swig_obj[1] ;
41332
41333 if (!args) SWIG_fail;
41334 swig_obj[0] = args;
41335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41336 if (!SWIG_IsOK(res1)) {
41337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41338 }
41339 arg1 = reinterpret_cast< wxValidator * >(argp1);
41340 {
41341 PyThreadState* __tstate = wxPyBeginAllowThreads();
41342 result = (wxValidator *)(arg1)->Clone();
41343 wxPyEndAllowThreads(__tstate);
41344 if (PyErr_Occurred()) SWIG_fail;
41345 }
41346 {
41347 resultobj = wxPyMake_wxObject(result, 0);
41348 }
41349 return resultobj;
41350 fail:
41351 return NULL;
41352 }
41353
41354
41355 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41356 PyObject *resultobj = 0;
41357 wxValidator *arg1 = (wxValidator *) 0 ;
41358 wxWindow *arg2 = (wxWindow *) 0 ;
41359 bool result;
41360 void *argp1 = 0 ;
41361 int res1 = 0 ;
41362 void *argp2 = 0 ;
41363 int res2 = 0 ;
41364 PyObject * obj0 = 0 ;
41365 PyObject * obj1 = 0 ;
41366 char * kwnames[] = {
41367 (char *) "self",(char *) "parent", NULL
41368 };
41369
41370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41372 if (!SWIG_IsOK(res1)) {
41373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41374 }
41375 arg1 = reinterpret_cast< wxValidator * >(argp1);
41376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41377 if (!SWIG_IsOK(res2)) {
41378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41379 }
41380 arg2 = reinterpret_cast< wxWindow * >(argp2);
41381 {
41382 PyThreadState* __tstate = wxPyBeginAllowThreads();
41383 result = (bool)(arg1)->Validate(arg2);
41384 wxPyEndAllowThreads(__tstate);
41385 if (PyErr_Occurred()) SWIG_fail;
41386 }
41387 {
41388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41389 }
41390 return resultobj;
41391 fail:
41392 return NULL;
41393 }
41394
41395
41396 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41397 PyObject *resultobj = 0;
41398 wxValidator *arg1 = (wxValidator *) 0 ;
41399 bool result;
41400 void *argp1 = 0 ;
41401 int res1 = 0 ;
41402 PyObject *swig_obj[1] ;
41403
41404 if (!args) SWIG_fail;
41405 swig_obj[0] = args;
41406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41407 if (!SWIG_IsOK(res1)) {
41408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41409 }
41410 arg1 = reinterpret_cast< wxValidator * >(argp1);
41411 {
41412 PyThreadState* __tstate = wxPyBeginAllowThreads();
41413 result = (bool)(arg1)->TransferToWindow();
41414 wxPyEndAllowThreads(__tstate);
41415 if (PyErr_Occurred()) SWIG_fail;
41416 }
41417 {
41418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41419 }
41420 return resultobj;
41421 fail:
41422 return NULL;
41423 }
41424
41425
41426 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41427 PyObject *resultobj = 0;
41428 wxValidator *arg1 = (wxValidator *) 0 ;
41429 bool result;
41430 void *argp1 = 0 ;
41431 int res1 = 0 ;
41432 PyObject *swig_obj[1] ;
41433
41434 if (!args) SWIG_fail;
41435 swig_obj[0] = args;
41436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41437 if (!SWIG_IsOK(res1)) {
41438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41439 }
41440 arg1 = reinterpret_cast< wxValidator * >(argp1);
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 result = (bool)(arg1)->TransferFromWindow();
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 {
41448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41449 }
41450 return resultobj;
41451 fail:
41452 return NULL;
41453 }
41454
41455
41456 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41457 PyObject *resultobj = 0;
41458 wxValidator *arg1 = (wxValidator *) 0 ;
41459 wxWindow *result = 0 ;
41460 void *argp1 = 0 ;
41461 int res1 = 0 ;
41462 PyObject *swig_obj[1] ;
41463
41464 if (!args) SWIG_fail;
41465 swig_obj[0] = args;
41466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41467 if (!SWIG_IsOK(res1)) {
41468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41469 }
41470 arg1 = reinterpret_cast< wxValidator * >(argp1);
41471 {
41472 PyThreadState* __tstate = wxPyBeginAllowThreads();
41473 result = (wxWindow *)(arg1)->GetWindow();
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 {
41478 resultobj = wxPyMake_wxObject(result, 0);
41479 }
41480 return resultobj;
41481 fail:
41482 return NULL;
41483 }
41484
41485
41486 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41487 PyObject *resultobj = 0;
41488 wxValidator *arg1 = (wxValidator *) 0 ;
41489 wxWindow *arg2 = (wxWindow *) 0 ;
41490 void *argp1 = 0 ;
41491 int res1 = 0 ;
41492 void *argp2 = 0 ;
41493 int res2 = 0 ;
41494 PyObject * obj0 = 0 ;
41495 PyObject * obj1 = 0 ;
41496 char * kwnames[] = {
41497 (char *) "self",(char *) "window", NULL
41498 };
41499
41500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41502 if (!SWIG_IsOK(res1)) {
41503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41504 }
41505 arg1 = reinterpret_cast< wxValidator * >(argp1);
41506 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41507 if (!SWIG_IsOK(res2)) {
41508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41509 }
41510 arg2 = reinterpret_cast< wxWindow * >(argp2);
41511 {
41512 PyThreadState* __tstate = wxPyBeginAllowThreads();
41513 (arg1)->SetWindow(arg2);
41514 wxPyEndAllowThreads(__tstate);
41515 if (PyErr_Occurred()) SWIG_fail;
41516 }
41517 resultobj = SWIG_Py_Void();
41518 return resultobj;
41519 fail:
41520 return NULL;
41521 }
41522
41523
41524 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41525 PyObject *resultobj = 0;
41526 bool result;
41527
41528 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41529 {
41530 PyThreadState* __tstate = wxPyBeginAllowThreads();
41531 result = (bool)wxValidator::IsSilent();
41532 wxPyEndAllowThreads(__tstate);
41533 if (PyErr_Occurred()) SWIG_fail;
41534 }
41535 {
41536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41537 }
41538 return resultobj;
41539 fail:
41540 return NULL;
41541 }
41542
41543
41544 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41545 PyObject *resultobj = 0;
41546 int arg1 = (int) true ;
41547 int val1 ;
41548 int ecode1 = 0 ;
41549 PyObject * obj0 = 0 ;
41550 char * kwnames[] = {
41551 (char *) "doIt", NULL
41552 };
41553
41554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41555 if (obj0) {
41556 ecode1 = SWIG_AsVal_int(obj0, &val1);
41557 if (!SWIG_IsOK(ecode1)) {
41558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41559 }
41560 arg1 = static_cast< int >(val1);
41561 }
41562 {
41563 PyThreadState* __tstate = wxPyBeginAllowThreads();
41564 wxValidator::SetBellOnError(arg1);
41565 wxPyEndAllowThreads(__tstate);
41566 if (PyErr_Occurred()) SWIG_fail;
41567 }
41568 resultobj = SWIG_Py_Void();
41569 return resultobj;
41570 fail:
41571 return NULL;
41572 }
41573
41574
41575 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41576 PyObject *obj;
41577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41578 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41579 return SWIG_Py_Void();
41580 }
41581
41582 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41583 return SWIG_Python_InitShadowInstance(args);
41584 }
41585
41586 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41587 PyObject *resultobj = 0;
41588 wxPyValidator *result = 0 ;
41589
41590 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41591 {
41592 PyThreadState* __tstate = wxPyBeginAllowThreads();
41593 result = (wxPyValidator *)new wxPyValidator();
41594 wxPyEndAllowThreads(__tstate);
41595 if (PyErr_Occurred()) SWIG_fail;
41596 }
41597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41598 return resultobj;
41599 fail:
41600 return NULL;
41601 }
41602
41603
41604 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41605 PyObject *resultobj = 0;
41606 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41607 PyObject *arg2 = (PyObject *) 0 ;
41608 PyObject *arg3 = (PyObject *) 0 ;
41609 int arg4 = (int) 1 ;
41610 void *argp1 = 0 ;
41611 int res1 = 0 ;
41612 int val4 ;
41613 int ecode4 = 0 ;
41614 PyObject * obj0 = 0 ;
41615 PyObject * obj1 = 0 ;
41616 PyObject * obj2 = 0 ;
41617 PyObject * obj3 = 0 ;
41618 char * kwnames[] = {
41619 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41620 };
41621
41622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41624 if (!SWIG_IsOK(res1)) {
41625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41626 }
41627 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41628 arg2 = obj1;
41629 arg3 = obj2;
41630 if (obj3) {
41631 ecode4 = SWIG_AsVal_int(obj3, &val4);
41632 if (!SWIG_IsOK(ecode4)) {
41633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41634 }
41635 arg4 = static_cast< int >(val4);
41636 }
41637 {
41638 PyThreadState* __tstate = wxPyBeginAllowThreads();
41639 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41640 wxPyEndAllowThreads(__tstate);
41641 if (PyErr_Occurred()) SWIG_fail;
41642 }
41643 resultobj = SWIG_Py_Void();
41644 return resultobj;
41645 fail:
41646 return NULL;
41647 }
41648
41649
41650 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41651 PyObject *obj;
41652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41653 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41654 return SWIG_Py_Void();
41655 }
41656
41657 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41658 return SWIG_Python_InitShadowInstance(args);
41659 }
41660
41661 SWIGINTERN int DefaultValidator_set(PyObject *) {
41662 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41663 return 1;
41664 }
41665
41666
41667 SWIGINTERN PyObject *DefaultValidator_get(void) {
41668 PyObject *pyobj = 0;
41669
41670 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41671 return pyobj;
41672 }
41673
41674
41675 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41676 PyObject *resultobj = 0;
41677 wxString const &arg1_defvalue = wxPyEmptyString ;
41678 wxString *arg1 = (wxString *) &arg1_defvalue ;
41679 long arg2 = (long) 0 ;
41680 wxMenu *result = 0 ;
41681 bool temp1 = false ;
41682 long val2 ;
41683 int ecode2 = 0 ;
41684 PyObject * obj0 = 0 ;
41685 PyObject * obj1 = 0 ;
41686 char * kwnames[] = {
41687 (char *) "title",(char *) "style", NULL
41688 };
41689
41690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41691 if (obj0) {
41692 {
41693 arg1 = wxString_in_helper(obj0);
41694 if (arg1 == NULL) SWIG_fail;
41695 temp1 = true;
41696 }
41697 }
41698 if (obj1) {
41699 ecode2 = SWIG_AsVal_long(obj1, &val2);
41700 if (!SWIG_IsOK(ecode2)) {
41701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41702 }
41703 arg2 = static_cast< long >(val2);
41704 }
41705 {
41706 if (!wxPyCheckForApp()) SWIG_fail;
41707 PyThreadState* __tstate = wxPyBeginAllowThreads();
41708 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41709 wxPyEndAllowThreads(__tstate);
41710 if (PyErr_Occurred()) SWIG_fail;
41711 }
41712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41713 {
41714 if (temp1)
41715 delete arg1;
41716 }
41717 return resultobj;
41718 fail:
41719 {
41720 if (temp1)
41721 delete arg1;
41722 }
41723 return NULL;
41724 }
41725
41726
41727 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41728 PyObject *resultobj = 0;
41729 wxMenu *arg1 = (wxMenu *) 0 ;
41730 int arg2 ;
41731 wxString const &arg3_defvalue = wxPyEmptyString ;
41732 wxString *arg3 = (wxString *) &arg3_defvalue ;
41733 wxString const &arg4_defvalue = wxPyEmptyString ;
41734 wxString *arg4 = (wxString *) &arg4_defvalue ;
41735 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41736 wxMenuItem *result = 0 ;
41737 void *argp1 = 0 ;
41738 int res1 = 0 ;
41739 int val2 ;
41740 int ecode2 = 0 ;
41741 bool temp3 = false ;
41742 bool temp4 = false ;
41743 int val5 ;
41744 int ecode5 = 0 ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 PyObject * obj2 = 0 ;
41748 PyObject * obj3 = 0 ;
41749 PyObject * obj4 = 0 ;
41750 char * kwnames[] = {
41751 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41752 };
41753
41754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41756 if (!SWIG_IsOK(res1)) {
41757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41758 }
41759 arg1 = reinterpret_cast< wxMenu * >(argp1);
41760 ecode2 = SWIG_AsVal_int(obj1, &val2);
41761 if (!SWIG_IsOK(ecode2)) {
41762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41763 }
41764 arg2 = static_cast< int >(val2);
41765 if (obj2) {
41766 {
41767 arg3 = wxString_in_helper(obj2);
41768 if (arg3 == NULL) SWIG_fail;
41769 temp3 = true;
41770 }
41771 }
41772 if (obj3) {
41773 {
41774 arg4 = wxString_in_helper(obj3);
41775 if (arg4 == NULL) SWIG_fail;
41776 temp4 = true;
41777 }
41778 }
41779 if (obj4) {
41780 ecode5 = SWIG_AsVal_int(obj4, &val5);
41781 if (!SWIG_IsOK(ecode5)) {
41782 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41783 }
41784 arg5 = static_cast< wxItemKind >(val5);
41785 }
41786 {
41787 PyThreadState* __tstate = wxPyBeginAllowThreads();
41788 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41789 wxPyEndAllowThreads(__tstate);
41790 if (PyErr_Occurred()) SWIG_fail;
41791 }
41792 {
41793 resultobj = wxPyMake_wxObject(result, (bool)0);
41794 }
41795 {
41796 if (temp3)
41797 delete arg3;
41798 }
41799 {
41800 if (temp4)
41801 delete arg4;
41802 }
41803 return resultobj;
41804 fail:
41805 {
41806 if (temp3)
41807 delete arg3;
41808 }
41809 {
41810 if (temp4)
41811 delete arg4;
41812 }
41813 return NULL;
41814 }
41815
41816
41817 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41818 PyObject *resultobj = 0;
41819 wxMenu *arg1 = (wxMenu *) 0 ;
41820 wxMenuItem *result = 0 ;
41821 void *argp1 = 0 ;
41822 int res1 = 0 ;
41823 PyObject *swig_obj[1] ;
41824
41825 if (!args) SWIG_fail;
41826 swig_obj[0] = args;
41827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41828 if (!SWIG_IsOK(res1)) {
41829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41830 }
41831 arg1 = reinterpret_cast< wxMenu * >(argp1);
41832 {
41833 PyThreadState* __tstate = wxPyBeginAllowThreads();
41834 result = (wxMenuItem *)(arg1)->AppendSeparator();
41835 wxPyEndAllowThreads(__tstate);
41836 if (PyErr_Occurred()) SWIG_fail;
41837 }
41838 {
41839 resultobj = wxPyMake_wxObject(result, (bool)0);
41840 }
41841 return resultobj;
41842 fail:
41843 return NULL;
41844 }
41845
41846
41847 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41848 PyObject *resultobj = 0;
41849 wxMenu *arg1 = (wxMenu *) 0 ;
41850 int arg2 ;
41851 wxString *arg3 = 0 ;
41852 wxString const &arg4_defvalue = wxPyEmptyString ;
41853 wxString *arg4 = (wxString *) &arg4_defvalue ;
41854 wxMenuItem *result = 0 ;
41855 void *argp1 = 0 ;
41856 int res1 = 0 ;
41857 int val2 ;
41858 int ecode2 = 0 ;
41859 bool temp3 = false ;
41860 bool temp4 = false ;
41861 PyObject * obj0 = 0 ;
41862 PyObject * obj1 = 0 ;
41863 PyObject * obj2 = 0 ;
41864 PyObject * obj3 = 0 ;
41865 char * kwnames[] = {
41866 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41867 };
41868
41869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41871 if (!SWIG_IsOK(res1)) {
41872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41873 }
41874 arg1 = reinterpret_cast< wxMenu * >(argp1);
41875 ecode2 = SWIG_AsVal_int(obj1, &val2);
41876 if (!SWIG_IsOK(ecode2)) {
41877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41878 }
41879 arg2 = static_cast< int >(val2);
41880 {
41881 arg3 = wxString_in_helper(obj2);
41882 if (arg3 == NULL) SWIG_fail;
41883 temp3 = true;
41884 }
41885 if (obj3) {
41886 {
41887 arg4 = wxString_in_helper(obj3);
41888 if (arg4 == NULL) SWIG_fail;
41889 temp4 = true;
41890 }
41891 }
41892 {
41893 PyThreadState* __tstate = wxPyBeginAllowThreads();
41894 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41895 wxPyEndAllowThreads(__tstate);
41896 if (PyErr_Occurred()) SWIG_fail;
41897 }
41898 {
41899 resultobj = wxPyMake_wxObject(result, (bool)0);
41900 }
41901 {
41902 if (temp3)
41903 delete arg3;
41904 }
41905 {
41906 if (temp4)
41907 delete arg4;
41908 }
41909 return resultobj;
41910 fail:
41911 {
41912 if (temp3)
41913 delete arg3;
41914 }
41915 {
41916 if (temp4)
41917 delete arg4;
41918 }
41919 return NULL;
41920 }
41921
41922
41923 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41924 PyObject *resultobj = 0;
41925 wxMenu *arg1 = (wxMenu *) 0 ;
41926 int arg2 ;
41927 wxString *arg3 = 0 ;
41928 wxString const &arg4_defvalue = wxPyEmptyString ;
41929 wxString *arg4 = (wxString *) &arg4_defvalue ;
41930 wxMenuItem *result = 0 ;
41931 void *argp1 = 0 ;
41932 int res1 = 0 ;
41933 int val2 ;
41934 int ecode2 = 0 ;
41935 bool temp3 = false ;
41936 bool temp4 = false ;
41937 PyObject * obj0 = 0 ;
41938 PyObject * obj1 = 0 ;
41939 PyObject * obj2 = 0 ;
41940 PyObject * obj3 = 0 ;
41941 char * kwnames[] = {
41942 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41943 };
41944
41945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41947 if (!SWIG_IsOK(res1)) {
41948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41949 }
41950 arg1 = reinterpret_cast< wxMenu * >(argp1);
41951 ecode2 = SWIG_AsVal_int(obj1, &val2);
41952 if (!SWIG_IsOK(ecode2)) {
41953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41954 }
41955 arg2 = static_cast< int >(val2);
41956 {
41957 arg3 = wxString_in_helper(obj2);
41958 if (arg3 == NULL) SWIG_fail;
41959 temp3 = true;
41960 }
41961 if (obj3) {
41962 {
41963 arg4 = wxString_in_helper(obj3);
41964 if (arg4 == NULL) SWIG_fail;
41965 temp4 = true;
41966 }
41967 }
41968 {
41969 PyThreadState* __tstate = wxPyBeginAllowThreads();
41970 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41971 wxPyEndAllowThreads(__tstate);
41972 if (PyErr_Occurred()) SWIG_fail;
41973 }
41974 {
41975 resultobj = wxPyMake_wxObject(result, (bool)0);
41976 }
41977 {
41978 if (temp3)
41979 delete arg3;
41980 }
41981 {
41982 if (temp4)
41983 delete arg4;
41984 }
41985 return resultobj;
41986 fail:
41987 {
41988 if (temp3)
41989 delete arg3;
41990 }
41991 {
41992 if (temp4)
41993 delete arg4;
41994 }
41995 return NULL;
41996 }
41997
41998
41999 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42000 PyObject *resultobj = 0;
42001 wxMenu *arg1 = (wxMenu *) 0 ;
42002 int arg2 ;
42003 wxString *arg3 = 0 ;
42004 wxMenu *arg4 = (wxMenu *) 0 ;
42005 wxString const &arg5_defvalue = wxPyEmptyString ;
42006 wxString *arg5 = (wxString *) &arg5_defvalue ;
42007 wxMenuItem *result = 0 ;
42008 void *argp1 = 0 ;
42009 int res1 = 0 ;
42010 int val2 ;
42011 int ecode2 = 0 ;
42012 bool temp3 = false ;
42013 void *argp4 = 0 ;
42014 int res4 = 0 ;
42015 bool temp5 = false ;
42016 PyObject * obj0 = 0 ;
42017 PyObject * obj1 = 0 ;
42018 PyObject * obj2 = 0 ;
42019 PyObject * obj3 = 0 ;
42020 PyObject * obj4 = 0 ;
42021 char * kwnames[] = {
42022 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42023 };
42024
42025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42027 if (!SWIG_IsOK(res1)) {
42028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42029 }
42030 arg1 = reinterpret_cast< wxMenu * >(argp1);
42031 ecode2 = SWIG_AsVal_int(obj1, &val2);
42032 if (!SWIG_IsOK(ecode2)) {
42033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42034 }
42035 arg2 = static_cast< int >(val2);
42036 {
42037 arg3 = wxString_in_helper(obj2);
42038 if (arg3 == NULL) SWIG_fail;
42039 temp3 = true;
42040 }
42041 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42042 if (!SWIG_IsOK(res4)) {
42043 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42044 }
42045 arg4 = reinterpret_cast< wxMenu * >(argp4);
42046 if (obj4) {
42047 {
42048 arg5 = wxString_in_helper(obj4);
42049 if (arg5 == NULL) SWIG_fail;
42050 temp5 = true;
42051 }
42052 }
42053 {
42054 PyThreadState* __tstate = wxPyBeginAllowThreads();
42055 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42056 wxPyEndAllowThreads(__tstate);
42057 if (PyErr_Occurred()) SWIG_fail;
42058 }
42059 {
42060 resultobj = wxPyMake_wxObject(result, (bool)0);
42061 }
42062 {
42063 if (temp3)
42064 delete arg3;
42065 }
42066 {
42067 if (temp5)
42068 delete arg5;
42069 }
42070 return resultobj;
42071 fail:
42072 {
42073 if (temp3)
42074 delete arg3;
42075 }
42076 {
42077 if (temp5)
42078 delete arg5;
42079 }
42080 return NULL;
42081 }
42082
42083
42084 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42085 PyObject *resultobj = 0;
42086 wxMenu *arg1 = (wxMenu *) 0 ;
42087 wxMenu *arg2 = (wxMenu *) 0 ;
42088 wxString *arg3 = 0 ;
42089 wxString const &arg4_defvalue = wxPyEmptyString ;
42090 wxString *arg4 = (wxString *) &arg4_defvalue ;
42091 wxMenuItem *result = 0 ;
42092 void *argp1 = 0 ;
42093 int res1 = 0 ;
42094 void *argp2 = 0 ;
42095 int res2 = 0 ;
42096 bool temp3 = false ;
42097 bool temp4 = false ;
42098 PyObject * obj0 = 0 ;
42099 PyObject * obj1 = 0 ;
42100 PyObject * obj2 = 0 ;
42101 PyObject * obj3 = 0 ;
42102 char * kwnames[] = {
42103 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42104 };
42105
42106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42108 if (!SWIG_IsOK(res1)) {
42109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42110 }
42111 arg1 = reinterpret_cast< wxMenu * >(argp1);
42112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42113 if (!SWIG_IsOK(res2)) {
42114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42115 }
42116 arg2 = reinterpret_cast< wxMenu * >(argp2);
42117 {
42118 arg3 = wxString_in_helper(obj2);
42119 if (arg3 == NULL) SWIG_fail;
42120 temp3 = true;
42121 }
42122 if (obj3) {
42123 {
42124 arg4 = wxString_in_helper(obj3);
42125 if (arg4 == NULL) SWIG_fail;
42126 temp4 = true;
42127 }
42128 }
42129 {
42130 PyThreadState* __tstate = wxPyBeginAllowThreads();
42131 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42132 wxPyEndAllowThreads(__tstate);
42133 if (PyErr_Occurred()) SWIG_fail;
42134 }
42135 {
42136 resultobj = wxPyMake_wxObject(result, (bool)0);
42137 }
42138 {
42139 if (temp3)
42140 delete arg3;
42141 }
42142 {
42143 if (temp4)
42144 delete arg4;
42145 }
42146 return resultobj;
42147 fail:
42148 {
42149 if (temp3)
42150 delete arg3;
42151 }
42152 {
42153 if (temp4)
42154 delete arg4;
42155 }
42156 return NULL;
42157 }
42158
42159
42160 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42161 PyObject *resultobj = 0;
42162 wxMenu *arg1 = (wxMenu *) 0 ;
42163 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42164 wxMenuItem *result = 0 ;
42165 void *argp1 = 0 ;
42166 int res1 = 0 ;
42167 int res2 = 0 ;
42168 PyObject * obj0 = 0 ;
42169 PyObject * obj1 = 0 ;
42170 char * kwnames[] = {
42171 (char *) "self",(char *) "item", NULL
42172 };
42173
42174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42176 if (!SWIG_IsOK(res1)) {
42177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42178 }
42179 arg1 = reinterpret_cast< wxMenu * >(argp1);
42180 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42181 if (!SWIG_IsOK(res2)) {
42182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42183 }
42184 {
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 result = (wxMenuItem *)(arg1)->Append(arg2);
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 {
42191 resultobj = wxPyMake_wxObject(result, (bool)0);
42192 }
42193 return resultobj;
42194 fail:
42195 return NULL;
42196 }
42197
42198
42199 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42200 PyObject *resultobj = 0;
42201 wxMenu *arg1 = (wxMenu *) 0 ;
42202 size_t arg2 ;
42203 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42204 wxMenuItem *result = 0 ;
42205 void *argp1 = 0 ;
42206 int res1 = 0 ;
42207 size_t val2 ;
42208 int ecode2 = 0 ;
42209 int res3 = 0 ;
42210 PyObject * obj0 = 0 ;
42211 PyObject * obj1 = 0 ;
42212 PyObject * obj2 = 0 ;
42213 char * kwnames[] = {
42214 (char *) "self",(char *) "pos",(char *) "item", NULL
42215 };
42216
42217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42219 if (!SWIG_IsOK(res1)) {
42220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42221 }
42222 arg1 = reinterpret_cast< wxMenu * >(argp1);
42223 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42224 if (!SWIG_IsOK(ecode2)) {
42225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42226 }
42227 arg2 = static_cast< size_t >(val2);
42228 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42229 if (!SWIG_IsOK(res3)) {
42230 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42231 }
42232 {
42233 PyThreadState* __tstate = wxPyBeginAllowThreads();
42234 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42235 wxPyEndAllowThreads(__tstate);
42236 if (PyErr_Occurred()) SWIG_fail;
42237 }
42238 {
42239 resultobj = wxPyMake_wxObject(result, (bool)0);
42240 }
42241 return resultobj;
42242 fail:
42243 return NULL;
42244 }
42245
42246
42247 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42248 PyObject *resultobj = 0;
42249 wxMenu *arg1 = (wxMenu *) 0 ;
42250 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42251 wxMenuItem *result = 0 ;
42252 void *argp1 = 0 ;
42253 int res1 = 0 ;
42254 int res2 = 0 ;
42255 PyObject * obj0 = 0 ;
42256 PyObject * obj1 = 0 ;
42257 char * kwnames[] = {
42258 (char *) "self",(char *) "item", NULL
42259 };
42260
42261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42263 if (!SWIG_IsOK(res1)) {
42264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42265 }
42266 arg1 = reinterpret_cast< wxMenu * >(argp1);
42267 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42268 if (!SWIG_IsOK(res2)) {
42269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42270 }
42271 {
42272 PyThreadState* __tstate = wxPyBeginAllowThreads();
42273 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42274 wxPyEndAllowThreads(__tstate);
42275 if (PyErr_Occurred()) SWIG_fail;
42276 }
42277 {
42278 resultobj = wxPyMake_wxObject(result, (bool)0);
42279 }
42280 return resultobj;
42281 fail:
42282 return NULL;
42283 }
42284
42285
42286 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42287 PyObject *resultobj = 0;
42288 wxMenu *arg1 = (wxMenu *) 0 ;
42289 void *argp1 = 0 ;
42290 int res1 = 0 ;
42291 PyObject *swig_obj[1] ;
42292
42293 if (!args) SWIG_fail;
42294 swig_obj[0] = args;
42295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42296 if (!SWIG_IsOK(res1)) {
42297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42298 }
42299 arg1 = reinterpret_cast< wxMenu * >(argp1);
42300 {
42301 PyThreadState* __tstate = wxPyBeginAllowThreads();
42302 (arg1)->Break();
42303 wxPyEndAllowThreads(__tstate);
42304 if (PyErr_Occurred()) SWIG_fail;
42305 }
42306 resultobj = SWIG_Py_Void();
42307 return resultobj;
42308 fail:
42309 return NULL;
42310 }
42311
42312
42313 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42314 PyObject *resultobj = 0;
42315 wxMenu *arg1 = (wxMenu *) 0 ;
42316 size_t arg2 ;
42317 int arg3 ;
42318 wxString const &arg4_defvalue = wxPyEmptyString ;
42319 wxString *arg4 = (wxString *) &arg4_defvalue ;
42320 wxString const &arg5_defvalue = wxPyEmptyString ;
42321 wxString *arg5 = (wxString *) &arg5_defvalue ;
42322 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42323 wxMenuItem *result = 0 ;
42324 void *argp1 = 0 ;
42325 int res1 = 0 ;
42326 size_t val2 ;
42327 int ecode2 = 0 ;
42328 int val3 ;
42329 int ecode3 = 0 ;
42330 bool temp4 = false ;
42331 bool temp5 = false ;
42332 int val6 ;
42333 int ecode6 = 0 ;
42334 PyObject * obj0 = 0 ;
42335 PyObject * obj1 = 0 ;
42336 PyObject * obj2 = 0 ;
42337 PyObject * obj3 = 0 ;
42338 PyObject * obj4 = 0 ;
42339 PyObject * obj5 = 0 ;
42340 char * kwnames[] = {
42341 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42342 };
42343
42344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42346 if (!SWIG_IsOK(res1)) {
42347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42348 }
42349 arg1 = reinterpret_cast< wxMenu * >(argp1);
42350 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42351 if (!SWIG_IsOK(ecode2)) {
42352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42353 }
42354 arg2 = static_cast< size_t >(val2);
42355 ecode3 = SWIG_AsVal_int(obj2, &val3);
42356 if (!SWIG_IsOK(ecode3)) {
42357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42358 }
42359 arg3 = static_cast< int >(val3);
42360 if (obj3) {
42361 {
42362 arg4 = wxString_in_helper(obj3);
42363 if (arg4 == NULL) SWIG_fail;
42364 temp4 = true;
42365 }
42366 }
42367 if (obj4) {
42368 {
42369 arg5 = wxString_in_helper(obj4);
42370 if (arg5 == NULL) SWIG_fail;
42371 temp5 = true;
42372 }
42373 }
42374 if (obj5) {
42375 ecode6 = SWIG_AsVal_int(obj5, &val6);
42376 if (!SWIG_IsOK(ecode6)) {
42377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42378 }
42379 arg6 = static_cast< wxItemKind >(val6);
42380 }
42381 {
42382 PyThreadState* __tstate = wxPyBeginAllowThreads();
42383 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42384 wxPyEndAllowThreads(__tstate);
42385 if (PyErr_Occurred()) SWIG_fail;
42386 }
42387 {
42388 resultobj = wxPyMake_wxObject(result, (bool)0);
42389 }
42390 {
42391 if (temp4)
42392 delete arg4;
42393 }
42394 {
42395 if (temp5)
42396 delete arg5;
42397 }
42398 return resultobj;
42399 fail:
42400 {
42401 if (temp4)
42402 delete arg4;
42403 }
42404 {
42405 if (temp5)
42406 delete arg5;
42407 }
42408 return NULL;
42409 }
42410
42411
42412 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42413 PyObject *resultobj = 0;
42414 wxMenu *arg1 = (wxMenu *) 0 ;
42415 size_t arg2 ;
42416 wxMenuItem *result = 0 ;
42417 void *argp1 = 0 ;
42418 int res1 = 0 ;
42419 size_t val2 ;
42420 int ecode2 = 0 ;
42421 PyObject * obj0 = 0 ;
42422 PyObject * obj1 = 0 ;
42423 char * kwnames[] = {
42424 (char *) "self",(char *) "pos", NULL
42425 };
42426
42427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42429 if (!SWIG_IsOK(res1)) {
42430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42431 }
42432 arg1 = reinterpret_cast< wxMenu * >(argp1);
42433 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42434 if (!SWIG_IsOK(ecode2)) {
42435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42436 }
42437 arg2 = static_cast< size_t >(val2);
42438 {
42439 PyThreadState* __tstate = wxPyBeginAllowThreads();
42440 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42441 wxPyEndAllowThreads(__tstate);
42442 if (PyErr_Occurred()) SWIG_fail;
42443 }
42444 {
42445 resultobj = wxPyMake_wxObject(result, (bool)0);
42446 }
42447 return resultobj;
42448 fail:
42449 return NULL;
42450 }
42451
42452
42453 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42454 PyObject *resultobj = 0;
42455 wxMenu *arg1 = (wxMenu *) 0 ;
42456 size_t arg2 ;
42457 int arg3 ;
42458 wxString *arg4 = 0 ;
42459 wxString const &arg5_defvalue = wxPyEmptyString ;
42460 wxString *arg5 = (wxString *) &arg5_defvalue ;
42461 wxMenuItem *result = 0 ;
42462 void *argp1 = 0 ;
42463 int res1 = 0 ;
42464 size_t val2 ;
42465 int ecode2 = 0 ;
42466 int val3 ;
42467 int ecode3 = 0 ;
42468 bool temp4 = false ;
42469 bool temp5 = false ;
42470 PyObject * obj0 = 0 ;
42471 PyObject * obj1 = 0 ;
42472 PyObject * obj2 = 0 ;
42473 PyObject * obj3 = 0 ;
42474 PyObject * obj4 = 0 ;
42475 char * kwnames[] = {
42476 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42477 };
42478
42479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42481 if (!SWIG_IsOK(res1)) {
42482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42483 }
42484 arg1 = reinterpret_cast< wxMenu * >(argp1);
42485 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42486 if (!SWIG_IsOK(ecode2)) {
42487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42488 }
42489 arg2 = static_cast< size_t >(val2);
42490 ecode3 = SWIG_AsVal_int(obj2, &val3);
42491 if (!SWIG_IsOK(ecode3)) {
42492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42493 }
42494 arg3 = static_cast< int >(val3);
42495 {
42496 arg4 = wxString_in_helper(obj3);
42497 if (arg4 == NULL) SWIG_fail;
42498 temp4 = true;
42499 }
42500 if (obj4) {
42501 {
42502 arg5 = wxString_in_helper(obj4);
42503 if (arg5 == NULL) SWIG_fail;
42504 temp5 = true;
42505 }
42506 }
42507 {
42508 PyThreadState* __tstate = wxPyBeginAllowThreads();
42509 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42510 wxPyEndAllowThreads(__tstate);
42511 if (PyErr_Occurred()) SWIG_fail;
42512 }
42513 {
42514 resultobj = wxPyMake_wxObject(result, (bool)0);
42515 }
42516 {
42517 if (temp4)
42518 delete arg4;
42519 }
42520 {
42521 if (temp5)
42522 delete arg5;
42523 }
42524 return resultobj;
42525 fail:
42526 {
42527 if (temp4)
42528 delete arg4;
42529 }
42530 {
42531 if (temp5)
42532 delete arg5;
42533 }
42534 return NULL;
42535 }
42536
42537
42538 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42539 PyObject *resultobj = 0;
42540 wxMenu *arg1 = (wxMenu *) 0 ;
42541 size_t arg2 ;
42542 int arg3 ;
42543 wxString *arg4 = 0 ;
42544 wxString const &arg5_defvalue = wxPyEmptyString ;
42545 wxString *arg5 = (wxString *) &arg5_defvalue ;
42546 wxMenuItem *result = 0 ;
42547 void *argp1 = 0 ;
42548 int res1 = 0 ;
42549 size_t val2 ;
42550 int ecode2 = 0 ;
42551 int val3 ;
42552 int ecode3 = 0 ;
42553 bool temp4 = false ;
42554 bool temp5 = false ;
42555 PyObject * obj0 = 0 ;
42556 PyObject * obj1 = 0 ;
42557 PyObject * obj2 = 0 ;
42558 PyObject * obj3 = 0 ;
42559 PyObject * obj4 = 0 ;
42560 char * kwnames[] = {
42561 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42562 };
42563
42564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42566 if (!SWIG_IsOK(res1)) {
42567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42568 }
42569 arg1 = reinterpret_cast< wxMenu * >(argp1);
42570 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42571 if (!SWIG_IsOK(ecode2)) {
42572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42573 }
42574 arg2 = static_cast< size_t >(val2);
42575 ecode3 = SWIG_AsVal_int(obj2, &val3);
42576 if (!SWIG_IsOK(ecode3)) {
42577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42578 }
42579 arg3 = static_cast< int >(val3);
42580 {
42581 arg4 = wxString_in_helper(obj3);
42582 if (arg4 == NULL) SWIG_fail;
42583 temp4 = true;
42584 }
42585 if (obj4) {
42586 {
42587 arg5 = wxString_in_helper(obj4);
42588 if (arg5 == NULL) SWIG_fail;
42589 temp5 = true;
42590 }
42591 }
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42595 wxPyEndAllowThreads(__tstate);
42596 if (PyErr_Occurred()) SWIG_fail;
42597 }
42598 {
42599 resultobj = wxPyMake_wxObject(result, (bool)0);
42600 }
42601 {
42602 if (temp4)
42603 delete arg4;
42604 }
42605 {
42606 if (temp5)
42607 delete arg5;
42608 }
42609 return resultobj;
42610 fail:
42611 {
42612 if (temp4)
42613 delete arg4;
42614 }
42615 {
42616 if (temp5)
42617 delete arg5;
42618 }
42619 return NULL;
42620 }
42621
42622
42623 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42624 PyObject *resultobj = 0;
42625 wxMenu *arg1 = (wxMenu *) 0 ;
42626 size_t arg2 ;
42627 int arg3 ;
42628 wxString *arg4 = 0 ;
42629 wxMenu *arg5 = (wxMenu *) 0 ;
42630 wxString const &arg6_defvalue = wxPyEmptyString ;
42631 wxString *arg6 = (wxString *) &arg6_defvalue ;
42632 wxMenuItem *result = 0 ;
42633 void *argp1 = 0 ;
42634 int res1 = 0 ;
42635 size_t val2 ;
42636 int ecode2 = 0 ;
42637 int val3 ;
42638 int ecode3 = 0 ;
42639 bool temp4 = false ;
42640 void *argp5 = 0 ;
42641 int res5 = 0 ;
42642 bool temp6 = false ;
42643 PyObject * obj0 = 0 ;
42644 PyObject * obj1 = 0 ;
42645 PyObject * obj2 = 0 ;
42646 PyObject * obj3 = 0 ;
42647 PyObject * obj4 = 0 ;
42648 PyObject * obj5 = 0 ;
42649 char * kwnames[] = {
42650 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42651 };
42652
42653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42655 if (!SWIG_IsOK(res1)) {
42656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42657 }
42658 arg1 = reinterpret_cast< wxMenu * >(argp1);
42659 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42660 if (!SWIG_IsOK(ecode2)) {
42661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42662 }
42663 arg2 = static_cast< size_t >(val2);
42664 ecode3 = SWIG_AsVal_int(obj2, &val3);
42665 if (!SWIG_IsOK(ecode3)) {
42666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42667 }
42668 arg3 = static_cast< int >(val3);
42669 {
42670 arg4 = wxString_in_helper(obj3);
42671 if (arg4 == NULL) SWIG_fail;
42672 temp4 = true;
42673 }
42674 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42675 if (!SWIG_IsOK(res5)) {
42676 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42677 }
42678 arg5 = reinterpret_cast< wxMenu * >(argp5);
42679 if (obj5) {
42680 {
42681 arg6 = wxString_in_helper(obj5);
42682 if (arg6 == NULL) SWIG_fail;
42683 temp6 = true;
42684 }
42685 }
42686 {
42687 PyThreadState* __tstate = wxPyBeginAllowThreads();
42688 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42689 wxPyEndAllowThreads(__tstate);
42690 if (PyErr_Occurred()) SWIG_fail;
42691 }
42692 {
42693 resultobj = wxPyMake_wxObject(result, (bool)0);
42694 }
42695 {
42696 if (temp4)
42697 delete arg4;
42698 }
42699 {
42700 if (temp6)
42701 delete arg6;
42702 }
42703 return resultobj;
42704 fail:
42705 {
42706 if (temp4)
42707 delete arg4;
42708 }
42709 {
42710 if (temp6)
42711 delete arg6;
42712 }
42713 return NULL;
42714 }
42715
42716
42717 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42718 PyObject *resultobj = 0;
42719 wxMenu *arg1 = (wxMenu *) 0 ;
42720 int arg2 ;
42721 wxString const &arg3_defvalue = wxPyEmptyString ;
42722 wxString *arg3 = (wxString *) &arg3_defvalue ;
42723 wxString const &arg4_defvalue = wxPyEmptyString ;
42724 wxString *arg4 = (wxString *) &arg4_defvalue ;
42725 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42726 wxMenuItem *result = 0 ;
42727 void *argp1 = 0 ;
42728 int res1 = 0 ;
42729 int val2 ;
42730 int ecode2 = 0 ;
42731 bool temp3 = false ;
42732 bool temp4 = false ;
42733 int val5 ;
42734 int ecode5 = 0 ;
42735 PyObject * obj0 = 0 ;
42736 PyObject * obj1 = 0 ;
42737 PyObject * obj2 = 0 ;
42738 PyObject * obj3 = 0 ;
42739 PyObject * obj4 = 0 ;
42740 char * kwnames[] = {
42741 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42742 };
42743
42744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42746 if (!SWIG_IsOK(res1)) {
42747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42748 }
42749 arg1 = reinterpret_cast< wxMenu * >(argp1);
42750 ecode2 = SWIG_AsVal_int(obj1, &val2);
42751 if (!SWIG_IsOK(ecode2)) {
42752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42753 }
42754 arg2 = static_cast< int >(val2);
42755 if (obj2) {
42756 {
42757 arg3 = wxString_in_helper(obj2);
42758 if (arg3 == NULL) SWIG_fail;
42759 temp3 = true;
42760 }
42761 }
42762 if (obj3) {
42763 {
42764 arg4 = wxString_in_helper(obj3);
42765 if (arg4 == NULL) SWIG_fail;
42766 temp4 = true;
42767 }
42768 }
42769 if (obj4) {
42770 ecode5 = SWIG_AsVal_int(obj4, &val5);
42771 if (!SWIG_IsOK(ecode5)) {
42772 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42773 }
42774 arg5 = static_cast< wxItemKind >(val5);
42775 }
42776 {
42777 PyThreadState* __tstate = wxPyBeginAllowThreads();
42778 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42779 wxPyEndAllowThreads(__tstate);
42780 if (PyErr_Occurred()) SWIG_fail;
42781 }
42782 {
42783 resultobj = wxPyMake_wxObject(result, (bool)0);
42784 }
42785 {
42786 if (temp3)
42787 delete arg3;
42788 }
42789 {
42790 if (temp4)
42791 delete arg4;
42792 }
42793 return resultobj;
42794 fail:
42795 {
42796 if (temp3)
42797 delete arg3;
42798 }
42799 {
42800 if (temp4)
42801 delete arg4;
42802 }
42803 return NULL;
42804 }
42805
42806
42807 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42808 PyObject *resultobj = 0;
42809 wxMenu *arg1 = (wxMenu *) 0 ;
42810 wxMenuItem *result = 0 ;
42811 void *argp1 = 0 ;
42812 int res1 = 0 ;
42813 PyObject *swig_obj[1] ;
42814
42815 if (!args) SWIG_fail;
42816 swig_obj[0] = args;
42817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42818 if (!SWIG_IsOK(res1)) {
42819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42820 }
42821 arg1 = reinterpret_cast< wxMenu * >(argp1);
42822 {
42823 PyThreadState* __tstate = wxPyBeginAllowThreads();
42824 result = (wxMenuItem *)(arg1)->PrependSeparator();
42825 wxPyEndAllowThreads(__tstate);
42826 if (PyErr_Occurred()) SWIG_fail;
42827 }
42828 {
42829 resultobj = wxPyMake_wxObject(result, (bool)0);
42830 }
42831 return resultobj;
42832 fail:
42833 return NULL;
42834 }
42835
42836
42837 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42838 PyObject *resultobj = 0;
42839 wxMenu *arg1 = (wxMenu *) 0 ;
42840 int arg2 ;
42841 wxString *arg3 = 0 ;
42842 wxString const &arg4_defvalue = wxPyEmptyString ;
42843 wxString *arg4 = (wxString *) &arg4_defvalue ;
42844 wxMenuItem *result = 0 ;
42845 void *argp1 = 0 ;
42846 int res1 = 0 ;
42847 int val2 ;
42848 int ecode2 = 0 ;
42849 bool temp3 = false ;
42850 bool temp4 = false ;
42851 PyObject * obj0 = 0 ;
42852 PyObject * obj1 = 0 ;
42853 PyObject * obj2 = 0 ;
42854 PyObject * obj3 = 0 ;
42855 char * kwnames[] = {
42856 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42857 };
42858
42859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42861 if (!SWIG_IsOK(res1)) {
42862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42863 }
42864 arg1 = reinterpret_cast< wxMenu * >(argp1);
42865 ecode2 = SWIG_AsVal_int(obj1, &val2);
42866 if (!SWIG_IsOK(ecode2)) {
42867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42868 }
42869 arg2 = static_cast< int >(val2);
42870 {
42871 arg3 = wxString_in_helper(obj2);
42872 if (arg3 == NULL) SWIG_fail;
42873 temp3 = true;
42874 }
42875 if (obj3) {
42876 {
42877 arg4 = wxString_in_helper(obj3);
42878 if (arg4 == NULL) SWIG_fail;
42879 temp4 = true;
42880 }
42881 }
42882 {
42883 PyThreadState* __tstate = wxPyBeginAllowThreads();
42884 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42885 wxPyEndAllowThreads(__tstate);
42886 if (PyErr_Occurred()) SWIG_fail;
42887 }
42888 {
42889 resultobj = wxPyMake_wxObject(result, (bool)0);
42890 }
42891 {
42892 if (temp3)
42893 delete arg3;
42894 }
42895 {
42896 if (temp4)
42897 delete arg4;
42898 }
42899 return resultobj;
42900 fail:
42901 {
42902 if (temp3)
42903 delete arg3;
42904 }
42905 {
42906 if (temp4)
42907 delete arg4;
42908 }
42909 return NULL;
42910 }
42911
42912
42913 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42914 PyObject *resultobj = 0;
42915 wxMenu *arg1 = (wxMenu *) 0 ;
42916 int arg2 ;
42917 wxString *arg3 = 0 ;
42918 wxString const &arg4_defvalue = wxPyEmptyString ;
42919 wxString *arg4 = (wxString *) &arg4_defvalue ;
42920 wxMenuItem *result = 0 ;
42921 void *argp1 = 0 ;
42922 int res1 = 0 ;
42923 int val2 ;
42924 int ecode2 = 0 ;
42925 bool temp3 = false ;
42926 bool temp4 = false ;
42927 PyObject * obj0 = 0 ;
42928 PyObject * obj1 = 0 ;
42929 PyObject * obj2 = 0 ;
42930 PyObject * obj3 = 0 ;
42931 char * kwnames[] = {
42932 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42933 };
42934
42935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42937 if (!SWIG_IsOK(res1)) {
42938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42939 }
42940 arg1 = reinterpret_cast< wxMenu * >(argp1);
42941 ecode2 = SWIG_AsVal_int(obj1, &val2);
42942 if (!SWIG_IsOK(ecode2)) {
42943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42944 }
42945 arg2 = static_cast< int >(val2);
42946 {
42947 arg3 = wxString_in_helper(obj2);
42948 if (arg3 == NULL) SWIG_fail;
42949 temp3 = true;
42950 }
42951 if (obj3) {
42952 {
42953 arg4 = wxString_in_helper(obj3);
42954 if (arg4 == NULL) SWIG_fail;
42955 temp4 = true;
42956 }
42957 }
42958 {
42959 PyThreadState* __tstate = wxPyBeginAllowThreads();
42960 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42961 wxPyEndAllowThreads(__tstate);
42962 if (PyErr_Occurred()) SWIG_fail;
42963 }
42964 {
42965 resultobj = wxPyMake_wxObject(result, (bool)0);
42966 }
42967 {
42968 if (temp3)
42969 delete arg3;
42970 }
42971 {
42972 if (temp4)
42973 delete arg4;
42974 }
42975 return resultobj;
42976 fail:
42977 {
42978 if (temp3)
42979 delete arg3;
42980 }
42981 {
42982 if (temp4)
42983 delete arg4;
42984 }
42985 return NULL;
42986 }
42987
42988
42989 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42990 PyObject *resultobj = 0;
42991 wxMenu *arg1 = (wxMenu *) 0 ;
42992 int arg2 ;
42993 wxString *arg3 = 0 ;
42994 wxMenu *arg4 = (wxMenu *) 0 ;
42995 wxString const &arg5_defvalue = wxPyEmptyString ;
42996 wxString *arg5 = (wxString *) &arg5_defvalue ;
42997 wxMenuItem *result = 0 ;
42998 void *argp1 = 0 ;
42999 int res1 = 0 ;
43000 int val2 ;
43001 int ecode2 = 0 ;
43002 bool temp3 = false ;
43003 void *argp4 = 0 ;
43004 int res4 = 0 ;
43005 bool temp5 = false ;
43006 PyObject * obj0 = 0 ;
43007 PyObject * obj1 = 0 ;
43008 PyObject * obj2 = 0 ;
43009 PyObject * obj3 = 0 ;
43010 PyObject * obj4 = 0 ;
43011 char * kwnames[] = {
43012 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43013 };
43014
43015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43017 if (!SWIG_IsOK(res1)) {
43018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43019 }
43020 arg1 = reinterpret_cast< wxMenu * >(argp1);
43021 ecode2 = SWIG_AsVal_int(obj1, &val2);
43022 if (!SWIG_IsOK(ecode2)) {
43023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43024 }
43025 arg2 = static_cast< int >(val2);
43026 {
43027 arg3 = wxString_in_helper(obj2);
43028 if (arg3 == NULL) SWIG_fail;
43029 temp3 = true;
43030 }
43031 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43032 if (!SWIG_IsOK(res4)) {
43033 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43034 }
43035 arg4 = reinterpret_cast< wxMenu * >(argp4);
43036 if (obj4) {
43037 {
43038 arg5 = wxString_in_helper(obj4);
43039 if (arg5 == NULL) SWIG_fail;
43040 temp5 = true;
43041 }
43042 }
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43046 wxPyEndAllowThreads(__tstate);
43047 if (PyErr_Occurred()) SWIG_fail;
43048 }
43049 {
43050 resultobj = wxPyMake_wxObject(result, (bool)0);
43051 }
43052 {
43053 if (temp3)
43054 delete arg3;
43055 }
43056 {
43057 if (temp5)
43058 delete arg5;
43059 }
43060 return resultobj;
43061 fail:
43062 {
43063 if (temp3)
43064 delete arg3;
43065 }
43066 {
43067 if (temp5)
43068 delete arg5;
43069 }
43070 return NULL;
43071 }
43072
43073
43074 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43075 PyObject *resultobj = 0;
43076 wxMenu *arg1 = (wxMenu *) 0 ;
43077 int arg2 ;
43078 wxMenuItem *result = 0 ;
43079 void *argp1 = 0 ;
43080 int res1 = 0 ;
43081 int val2 ;
43082 int ecode2 = 0 ;
43083 PyObject * obj0 = 0 ;
43084 PyObject * obj1 = 0 ;
43085 char * kwnames[] = {
43086 (char *) "self",(char *) "id", NULL
43087 };
43088
43089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43091 if (!SWIG_IsOK(res1)) {
43092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43093 }
43094 arg1 = reinterpret_cast< wxMenu * >(argp1);
43095 ecode2 = SWIG_AsVal_int(obj1, &val2);
43096 if (!SWIG_IsOK(ecode2)) {
43097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43098 }
43099 arg2 = static_cast< int >(val2);
43100 {
43101 PyThreadState* __tstate = wxPyBeginAllowThreads();
43102 result = (wxMenuItem *)(arg1)->Remove(arg2);
43103 wxPyEndAllowThreads(__tstate);
43104 if (PyErr_Occurred()) SWIG_fail;
43105 }
43106 {
43107 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43108 }
43109 return resultobj;
43110 fail:
43111 return NULL;
43112 }
43113
43114
43115 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43116 PyObject *resultobj = 0;
43117 wxMenu *arg1 = (wxMenu *) 0 ;
43118 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43119 wxMenuItem *result = 0 ;
43120 void *argp1 = 0 ;
43121 int res1 = 0 ;
43122 void *argp2 = 0 ;
43123 int res2 = 0 ;
43124 PyObject * obj0 = 0 ;
43125 PyObject * obj1 = 0 ;
43126 char * kwnames[] = {
43127 (char *) "self",(char *) "item", NULL
43128 };
43129
43130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43132 if (!SWIG_IsOK(res1)) {
43133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43134 }
43135 arg1 = reinterpret_cast< wxMenu * >(argp1);
43136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43137 if (!SWIG_IsOK(res2)) {
43138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43139 }
43140 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43141 {
43142 PyThreadState* __tstate = wxPyBeginAllowThreads();
43143 result = (wxMenuItem *)(arg1)->Remove(arg2);
43144 wxPyEndAllowThreads(__tstate);
43145 if (PyErr_Occurred()) SWIG_fail;
43146 }
43147 {
43148 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43149 }
43150 return resultobj;
43151 fail:
43152 return NULL;
43153 }
43154
43155
43156 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43157 PyObject *resultobj = 0;
43158 wxMenu *arg1 = (wxMenu *) 0 ;
43159 int arg2 ;
43160 bool result;
43161 void *argp1 = 0 ;
43162 int res1 = 0 ;
43163 int val2 ;
43164 int ecode2 = 0 ;
43165 PyObject * obj0 = 0 ;
43166 PyObject * obj1 = 0 ;
43167 char * kwnames[] = {
43168 (char *) "self",(char *) "id", NULL
43169 };
43170
43171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43173 if (!SWIG_IsOK(res1)) {
43174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43175 }
43176 arg1 = reinterpret_cast< wxMenu * >(argp1);
43177 ecode2 = SWIG_AsVal_int(obj1, &val2);
43178 if (!SWIG_IsOK(ecode2)) {
43179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43180 }
43181 arg2 = static_cast< int >(val2);
43182 {
43183 PyThreadState* __tstate = wxPyBeginAllowThreads();
43184 result = (bool)(arg1)->Delete(arg2);
43185 wxPyEndAllowThreads(__tstate);
43186 if (PyErr_Occurred()) SWIG_fail;
43187 }
43188 {
43189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43190 }
43191 return resultobj;
43192 fail:
43193 return NULL;
43194 }
43195
43196
43197 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43198 PyObject *resultobj = 0;
43199 wxMenu *arg1 = (wxMenu *) 0 ;
43200 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43201 bool result;
43202 void *argp1 = 0 ;
43203 int res1 = 0 ;
43204 void *argp2 = 0 ;
43205 int res2 = 0 ;
43206 PyObject * obj0 = 0 ;
43207 PyObject * obj1 = 0 ;
43208 char * kwnames[] = {
43209 (char *) "self",(char *) "item", NULL
43210 };
43211
43212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43214 if (!SWIG_IsOK(res1)) {
43215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43216 }
43217 arg1 = reinterpret_cast< wxMenu * >(argp1);
43218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43219 if (!SWIG_IsOK(res2)) {
43220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43221 }
43222 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43223 {
43224 PyThreadState* __tstate = wxPyBeginAllowThreads();
43225 result = (bool)(arg1)->Delete(arg2);
43226 wxPyEndAllowThreads(__tstate);
43227 if (PyErr_Occurred()) SWIG_fail;
43228 }
43229 {
43230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43231 }
43232 return resultobj;
43233 fail:
43234 return NULL;
43235 }
43236
43237
43238 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43239 PyObject *resultobj = 0;
43240 wxMenu *arg1 = (wxMenu *) 0 ;
43241 void *argp1 = 0 ;
43242 int res1 = 0 ;
43243 PyObject *swig_obj[1] ;
43244
43245 if (!args) SWIG_fail;
43246 swig_obj[0] = args;
43247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43248 if (!SWIG_IsOK(res1)) {
43249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43250 }
43251 arg1 = reinterpret_cast< wxMenu * >(argp1);
43252 {
43253 PyThreadState* __tstate = wxPyBeginAllowThreads();
43254 wxMenu_Destroy(arg1);
43255 wxPyEndAllowThreads(__tstate);
43256 if (PyErr_Occurred()) SWIG_fail;
43257 }
43258 resultobj = SWIG_Py_Void();
43259 return resultobj;
43260 fail:
43261 return NULL;
43262 }
43263
43264
43265 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43266 PyObject *resultobj = 0;
43267 wxMenu *arg1 = (wxMenu *) 0 ;
43268 int arg2 ;
43269 bool result;
43270 void *argp1 = 0 ;
43271 int res1 = 0 ;
43272 int val2 ;
43273 int ecode2 = 0 ;
43274 PyObject * obj0 = 0 ;
43275 PyObject * obj1 = 0 ;
43276 char * kwnames[] = {
43277 (char *) "self",(char *) "id", NULL
43278 };
43279
43280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43282 if (!SWIG_IsOK(res1)) {
43283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43284 }
43285 arg1 = reinterpret_cast< wxMenu * >(argp1);
43286 ecode2 = SWIG_AsVal_int(obj1, &val2);
43287 if (!SWIG_IsOK(ecode2)) {
43288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43289 }
43290 arg2 = static_cast< int >(val2);
43291 {
43292 PyThreadState* __tstate = wxPyBeginAllowThreads();
43293 result = (bool)(arg1)->Destroy(arg2);
43294 wxPyEndAllowThreads(__tstate);
43295 if (PyErr_Occurred()) SWIG_fail;
43296 }
43297 {
43298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43299 }
43300 return resultobj;
43301 fail:
43302 return NULL;
43303 }
43304
43305
43306 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43307 PyObject *resultobj = 0;
43308 wxMenu *arg1 = (wxMenu *) 0 ;
43309 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43310 bool result;
43311 void *argp1 = 0 ;
43312 int res1 = 0 ;
43313 void *argp2 = 0 ;
43314 int res2 = 0 ;
43315 PyObject * obj0 = 0 ;
43316 PyObject * obj1 = 0 ;
43317 char * kwnames[] = {
43318 (char *) "self",(char *) "item", NULL
43319 };
43320
43321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43323 if (!SWIG_IsOK(res1)) {
43324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43325 }
43326 arg1 = reinterpret_cast< wxMenu * >(argp1);
43327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43328 if (!SWIG_IsOK(res2)) {
43329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43330 }
43331 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43332 {
43333 PyThreadState* __tstate = wxPyBeginAllowThreads();
43334 result = (bool)(arg1)->Destroy(arg2);
43335 wxPyEndAllowThreads(__tstate);
43336 if (PyErr_Occurred()) SWIG_fail;
43337 }
43338 {
43339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43340 }
43341 return resultobj;
43342 fail:
43343 return NULL;
43344 }
43345
43346
43347 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43348 PyObject *resultobj = 0;
43349 wxMenu *arg1 = (wxMenu *) 0 ;
43350 size_t result;
43351 void *argp1 = 0 ;
43352 int res1 = 0 ;
43353 PyObject *swig_obj[1] ;
43354
43355 if (!args) SWIG_fail;
43356 swig_obj[0] = args;
43357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43358 if (!SWIG_IsOK(res1)) {
43359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43360 }
43361 arg1 = reinterpret_cast< wxMenu * >(argp1);
43362 {
43363 PyThreadState* __tstate = wxPyBeginAllowThreads();
43364 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43365 wxPyEndAllowThreads(__tstate);
43366 if (PyErr_Occurred()) SWIG_fail;
43367 }
43368 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43369 return resultobj;
43370 fail:
43371 return NULL;
43372 }
43373
43374
43375 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43376 PyObject *resultobj = 0;
43377 wxMenu *arg1 = (wxMenu *) 0 ;
43378 PyObject *result = 0 ;
43379 void *argp1 = 0 ;
43380 int res1 = 0 ;
43381 PyObject *swig_obj[1] ;
43382
43383 if (!args) SWIG_fail;
43384 swig_obj[0] = args;
43385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43386 if (!SWIG_IsOK(res1)) {
43387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43388 }
43389 arg1 = reinterpret_cast< wxMenu * >(argp1);
43390 {
43391 PyThreadState* __tstate = wxPyBeginAllowThreads();
43392 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43393 wxPyEndAllowThreads(__tstate);
43394 if (PyErr_Occurred()) SWIG_fail;
43395 }
43396 resultobj = result;
43397 return resultobj;
43398 fail:
43399 return NULL;
43400 }
43401
43402
43403 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43404 PyObject *resultobj = 0;
43405 wxMenu *arg1 = (wxMenu *) 0 ;
43406 wxString *arg2 = 0 ;
43407 int result;
43408 void *argp1 = 0 ;
43409 int res1 = 0 ;
43410 bool temp2 = false ;
43411 PyObject * obj0 = 0 ;
43412 PyObject * obj1 = 0 ;
43413 char * kwnames[] = {
43414 (char *) "self",(char *) "item", NULL
43415 };
43416
43417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43419 if (!SWIG_IsOK(res1)) {
43420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43421 }
43422 arg1 = reinterpret_cast< wxMenu * >(argp1);
43423 {
43424 arg2 = wxString_in_helper(obj1);
43425 if (arg2 == NULL) SWIG_fail;
43426 temp2 = true;
43427 }
43428 {
43429 PyThreadState* __tstate = wxPyBeginAllowThreads();
43430 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43431 wxPyEndAllowThreads(__tstate);
43432 if (PyErr_Occurred()) SWIG_fail;
43433 }
43434 resultobj = SWIG_From_int(static_cast< int >(result));
43435 {
43436 if (temp2)
43437 delete arg2;
43438 }
43439 return resultobj;
43440 fail:
43441 {
43442 if (temp2)
43443 delete arg2;
43444 }
43445 return NULL;
43446 }
43447
43448
43449 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43450 PyObject *resultobj = 0;
43451 wxMenu *arg1 = (wxMenu *) 0 ;
43452 int arg2 ;
43453 wxMenuItem *result = 0 ;
43454 void *argp1 = 0 ;
43455 int res1 = 0 ;
43456 int val2 ;
43457 int ecode2 = 0 ;
43458 PyObject * obj0 = 0 ;
43459 PyObject * obj1 = 0 ;
43460 char * kwnames[] = {
43461 (char *) "self",(char *) "id", NULL
43462 };
43463
43464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43466 if (!SWIG_IsOK(res1)) {
43467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43468 }
43469 arg1 = reinterpret_cast< wxMenu * >(argp1);
43470 ecode2 = SWIG_AsVal_int(obj1, &val2);
43471 if (!SWIG_IsOK(ecode2)) {
43472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43473 }
43474 arg2 = static_cast< int >(val2);
43475 {
43476 PyThreadState* __tstate = wxPyBeginAllowThreads();
43477 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43478 wxPyEndAllowThreads(__tstate);
43479 if (PyErr_Occurred()) SWIG_fail;
43480 }
43481 {
43482 resultobj = wxPyMake_wxObject(result, (bool)0);
43483 }
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj = 0;
43492 wxMenu *arg1 = (wxMenu *) 0 ;
43493 size_t arg2 ;
43494 wxMenuItem *result = 0 ;
43495 void *argp1 = 0 ;
43496 int res1 = 0 ;
43497 size_t val2 ;
43498 int ecode2 = 0 ;
43499 PyObject * obj0 = 0 ;
43500 PyObject * obj1 = 0 ;
43501 char * kwnames[] = {
43502 (char *) "self",(char *) "position", NULL
43503 };
43504
43505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43507 if (!SWIG_IsOK(res1)) {
43508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43509 }
43510 arg1 = reinterpret_cast< wxMenu * >(argp1);
43511 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43512 if (!SWIG_IsOK(ecode2)) {
43513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43514 }
43515 arg2 = static_cast< size_t >(val2);
43516 {
43517 PyThreadState* __tstate = wxPyBeginAllowThreads();
43518 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43519 wxPyEndAllowThreads(__tstate);
43520 if (PyErr_Occurred()) SWIG_fail;
43521 }
43522 {
43523 resultobj = wxPyMake_wxObject(result, (bool)0);
43524 }
43525 return resultobj;
43526 fail:
43527 return NULL;
43528 }
43529
43530
43531 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43532 PyObject *resultobj = 0;
43533 wxMenu *arg1 = (wxMenu *) 0 ;
43534 int arg2 ;
43535 bool arg3 ;
43536 void *argp1 = 0 ;
43537 int res1 = 0 ;
43538 int val2 ;
43539 int ecode2 = 0 ;
43540 bool val3 ;
43541 int ecode3 = 0 ;
43542 PyObject * obj0 = 0 ;
43543 PyObject * obj1 = 0 ;
43544 PyObject * obj2 = 0 ;
43545 char * kwnames[] = {
43546 (char *) "self",(char *) "id",(char *) "enable", NULL
43547 };
43548
43549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43551 if (!SWIG_IsOK(res1)) {
43552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43553 }
43554 arg1 = reinterpret_cast< wxMenu * >(argp1);
43555 ecode2 = SWIG_AsVal_int(obj1, &val2);
43556 if (!SWIG_IsOK(ecode2)) {
43557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43558 }
43559 arg2 = static_cast< int >(val2);
43560 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43561 if (!SWIG_IsOK(ecode3)) {
43562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43563 }
43564 arg3 = static_cast< bool >(val3);
43565 {
43566 PyThreadState* __tstate = wxPyBeginAllowThreads();
43567 (arg1)->Enable(arg2,arg3);
43568 wxPyEndAllowThreads(__tstate);
43569 if (PyErr_Occurred()) SWIG_fail;
43570 }
43571 resultobj = SWIG_Py_Void();
43572 return resultobj;
43573 fail:
43574 return NULL;
43575 }
43576
43577
43578 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43579 PyObject *resultobj = 0;
43580 wxMenu *arg1 = (wxMenu *) 0 ;
43581 int arg2 ;
43582 bool result;
43583 void *argp1 = 0 ;
43584 int res1 = 0 ;
43585 int val2 ;
43586 int ecode2 = 0 ;
43587 PyObject * obj0 = 0 ;
43588 PyObject * obj1 = 0 ;
43589 char * kwnames[] = {
43590 (char *) "self",(char *) "id", NULL
43591 };
43592
43593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43595 if (!SWIG_IsOK(res1)) {
43596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43597 }
43598 arg1 = reinterpret_cast< wxMenu * >(argp1);
43599 ecode2 = SWIG_AsVal_int(obj1, &val2);
43600 if (!SWIG_IsOK(ecode2)) {
43601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43602 }
43603 arg2 = static_cast< int >(val2);
43604 {
43605 PyThreadState* __tstate = wxPyBeginAllowThreads();
43606 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43607 wxPyEndAllowThreads(__tstate);
43608 if (PyErr_Occurred()) SWIG_fail;
43609 }
43610 {
43611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43612 }
43613 return resultobj;
43614 fail:
43615 return NULL;
43616 }
43617
43618
43619 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43620 PyObject *resultobj = 0;
43621 wxMenu *arg1 = (wxMenu *) 0 ;
43622 int arg2 ;
43623 bool arg3 ;
43624 void *argp1 = 0 ;
43625 int res1 = 0 ;
43626 int val2 ;
43627 int ecode2 = 0 ;
43628 bool val3 ;
43629 int ecode3 = 0 ;
43630 PyObject * obj0 = 0 ;
43631 PyObject * obj1 = 0 ;
43632 PyObject * obj2 = 0 ;
43633 char * kwnames[] = {
43634 (char *) "self",(char *) "id",(char *) "check", NULL
43635 };
43636
43637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43639 if (!SWIG_IsOK(res1)) {
43640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43641 }
43642 arg1 = reinterpret_cast< wxMenu * >(argp1);
43643 ecode2 = SWIG_AsVal_int(obj1, &val2);
43644 if (!SWIG_IsOK(ecode2)) {
43645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43646 }
43647 arg2 = static_cast< int >(val2);
43648 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43649 if (!SWIG_IsOK(ecode3)) {
43650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43651 }
43652 arg3 = static_cast< bool >(val3);
43653 {
43654 PyThreadState* __tstate = wxPyBeginAllowThreads();
43655 (arg1)->Check(arg2,arg3);
43656 wxPyEndAllowThreads(__tstate);
43657 if (PyErr_Occurred()) SWIG_fail;
43658 }
43659 resultobj = SWIG_Py_Void();
43660 return resultobj;
43661 fail:
43662 return NULL;
43663 }
43664
43665
43666 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43667 PyObject *resultobj = 0;
43668 wxMenu *arg1 = (wxMenu *) 0 ;
43669 int arg2 ;
43670 bool result;
43671 void *argp1 = 0 ;
43672 int res1 = 0 ;
43673 int val2 ;
43674 int ecode2 = 0 ;
43675 PyObject * obj0 = 0 ;
43676 PyObject * obj1 = 0 ;
43677 char * kwnames[] = {
43678 (char *) "self",(char *) "id", NULL
43679 };
43680
43681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43683 if (!SWIG_IsOK(res1)) {
43684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43685 }
43686 arg1 = reinterpret_cast< wxMenu * >(argp1);
43687 ecode2 = SWIG_AsVal_int(obj1, &val2);
43688 if (!SWIG_IsOK(ecode2)) {
43689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43690 }
43691 arg2 = static_cast< int >(val2);
43692 {
43693 PyThreadState* __tstate = wxPyBeginAllowThreads();
43694 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43695 wxPyEndAllowThreads(__tstate);
43696 if (PyErr_Occurred()) SWIG_fail;
43697 }
43698 {
43699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43700 }
43701 return resultobj;
43702 fail:
43703 return NULL;
43704 }
43705
43706
43707 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43708 PyObject *resultobj = 0;
43709 wxMenu *arg1 = (wxMenu *) 0 ;
43710 int arg2 ;
43711 wxString *arg3 = 0 ;
43712 void *argp1 = 0 ;
43713 int res1 = 0 ;
43714 int val2 ;
43715 int ecode2 = 0 ;
43716 bool temp3 = false ;
43717 PyObject * obj0 = 0 ;
43718 PyObject * obj1 = 0 ;
43719 PyObject * obj2 = 0 ;
43720 char * kwnames[] = {
43721 (char *) "self",(char *) "id",(char *) "label", NULL
43722 };
43723
43724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43726 if (!SWIG_IsOK(res1)) {
43727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43728 }
43729 arg1 = reinterpret_cast< wxMenu * >(argp1);
43730 ecode2 = SWIG_AsVal_int(obj1, &val2);
43731 if (!SWIG_IsOK(ecode2)) {
43732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43733 }
43734 arg2 = static_cast< int >(val2);
43735 {
43736 arg3 = wxString_in_helper(obj2);
43737 if (arg3 == NULL) SWIG_fail;
43738 temp3 = true;
43739 }
43740 {
43741 PyThreadState* __tstate = wxPyBeginAllowThreads();
43742 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43743 wxPyEndAllowThreads(__tstate);
43744 if (PyErr_Occurred()) SWIG_fail;
43745 }
43746 resultobj = SWIG_Py_Void();
43747 {
43748 if (temp3)
43749 delete arg3;
43750 }
43751 return resultobj;
43752 fail:
43753 {
43754 if (temp3)
43755 delete arg3;
43756 }
43757 return NULL;
43758 }
43759
43760
43761 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43762 PyObject *resultobj = 0;
43763 wxMenu *arg1 = (wxMenu *) 0 ;
43764 int arg2 ;
43765 wxString result;
43766 void *argp1 = 0 ;
43767 int res1 = 0 ;
43768 int val2 ;
43769 int ecode2 = 0 ;
43770 PyObject * obj0 = 0 ;
43771 PyObject * obj1 = 0 ;
43772 char * kwnames[] = {
43773 (char *) "self",(char *) "id", NULL
43774 };
43775
43776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43778 if (!SWIG_IsOK(res1)) {
43779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43780 }
43781 arg1 = reinterpret_cast< wxMenu * >(argp1);
43782 ecode2 = SWIG_AsVal_int(obj1, &val2);
43783 if (!SWIG_IsOK(ecode2)) {
43784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43785 }
43786 arg2 = static_cast< int >(val2);
43787 {
43788 PyThreadState* __tstate = wxPyBeginAllowThreads();
43789 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43790 wxPyEndAllowThreads(__tstate);
43791 if (PyErr_Occurred()) SWIG_fail;
43792 }
43793 {
43794 #if wxUSE_UNICODE
43795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43796 #else
43797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43798 #endif
43799 }
43800 return resultobj;
43801 fail:
43802 return NULL;
43803 }
43804
43805
43806 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43807 PyObject *resultobj = 0;
43808 wxMenu *arg1 = (wxMenu *) 0 ;
43809 int arg2 ;
43810 wxString *arg3 = 0 ;
43811 void *argp1 = 0 ;
43812 int res1 = 0 ;
43813 int val2 ;
43814 int ecode2 = 0 ;
43815 bool temp3 = false ;
43816 PyObject * obj0 = 0 ;
43817 PyObject * obj1 = 0 ;
43818 PyObject * obj2 = 0 ;
43819 char * kwnames[] = {
43820 (char *) "self",(char *) "id",(char *) "helpString", NULL
43821 };
43822
43823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43825 if (!SWIG_IsOK(res1)) {
43826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43827 }
43828 arg1 = reinterpret_cast< wxMenu * >(argp1);
43829 ecode2 = SWIG_AsVal_int(obj1, &val2);
43830 if (!SWIG_IsOK(ecode2)) {
43831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43832 }
43833 arg2 = static_cast< int >(val2);
43834 {
43835 arg3 = wxString_in_helper(obj2);
43836 if (arg3 == NULL) SWIG_fail;
43837 temp3 = true;
43838 }
43839 {
43840 PyThreadState* __tstate = wxPyBeginAllowThreads();
43841 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43842 wxPyEndAllowThreads(__tstate);
43843 if (PyErr_Occurred()) SWIG_fail;
43844 }
43845 resultobj = SWIG_Py_Void();
43846 {
43847 if (temp3)
43848 delete arg3;
43849 }
43850 return resultobj;
43851 fail:
43852 {
43853 if (temp3)
43854 delete arg3;
43855 }
43856 return NULL;
43857 }
43858
43859
43860 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43861 PyObject *resultobj = 0;
43862 wxMenu *arg1 = (wxMenu *) 0 ;
43863 int arg2 ;
43864 wxString result;
43865 void *argp1 = 0 ;
43866 int res1 = 0 ;
43867 int val2 ;
43868 int ecode2 = 0 ;
43869 PyObject * obj0 = 0 ;
43870 PyObject * obj1 = 0 ;
43871 char * kwnames[] = {
43872 (char *) "self",(char *) "id", NULL
43873 };
43874
43875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43877 if (!SWIG_IsOK(res1)) {
43878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43879 }
43880 arg1 = reinterpret_cast< wxMenu * >(argp1);
43881 ecode2 = SWIG_AsVal_int(obj1, &val2);
43882 if (!SWIG_IsOK(ecode2)) {
43883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43884 }
43885 arg2 = static_cast< int >(val2);
43886 {
43887 PyThreadState* __tstate = wxPyBeginAllowThreads();
43888 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43889 wxPyEndAllowThreads(__tstate);
43890 if (PyErr_Occurred()) SWIG_fail;
43891 }
43892 {
43893 #if wxUSE_UNICODE
43894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43895 #else
43896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43897 #endif
43898 }
43899 return resultobj;
43900 fail:
43901 return NULL;
43902 }
43903
43904
43905 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43906 PyObject *resultobj = 0;
43907 wxMenu *arg1 = (wxMenu *) 0 ;
43908 wxString *arg2 = 0 ;
43909 void *argp1 = 0 ;
43910 int res1 = 0 ;
43911 bool temp2 = false ;
43912 PyObject * obj0 = 0 ;
43913 PyObject * obj1 = 0 ;
43914 char * kwnames[] = {
43915 (char *) "self",(char *) "title", NULL
43916 };
43917
43918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43920 if (!SWIG_IsOK(res1)) {
43921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43922 }
43923 arg1 = reinterpret_cast< wxMenu * >(argp1);
43924 {
43925 arg2 = wxString_in_helper(obj1);
43926 if (arg2 == NULL) SWIG_fail;
43927 temp2 = true;
43928 }
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 (arg1)->SetTitle((wxString const &)*arg2);
43932 wxPyEndAllowThreads(__tstate);
43933 if (PyErr_Occurred()) SWIG_fail;
43934 }
43935 resultobj = SWIG_Py_Void();
43936 {
43937 if (temp2)
43938 delete arg2;
43939 }
43940 return resultobj;
43941 fail:
43942 {
43943 if (temp2)
43944 delete arg2;
43945 }
43946 return NULL;
43947 }
43948
43949
43950 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43951 PyObject *resultobj = 0;
43952 wxMenu *arg1 = (wxMenu *) 0 ;
43953 wxString result;
43954 void *argp1 = 0 ;
43955 int res1 = 0 ;
43956 PyObject *swig_obj[1] ;
43957
43958 if (!args) SWIG_fail;
43959 swig_obj[0] = args;
43960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43961 if (!SWIG_IsOK(res1)) {
43962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43963 }
43964 arg1 = reinterpret_cast< wxMenu * >(argp1);
43965 {
43966 PyThreadState* __tstate = wxPyBeginAllowThreads();
43967 result = ((wxMenu const *)arg1)->GetTitle();
43968 wxPyEndAllowThreads(__tstate);
43969 if (PyErr_Occurred()) SWIG_fail;
43970 }
43971 {
43972 #if wxUSE_UNICODE
43973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43974 #else
43975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43976 #endif
43977 }
43978 return resultobj;
43979 fail:
43980 return NULL;
43981 }
43982
43983
43984 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43985 PyObject *resultobj = 0;
43986 wxMenu *arg1 = (wxMenu *) 0 ;
43987 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43988 void *argp1 = 0 ;
43989 int res1 = 0 ;
43990 void *argp2 = 0 ;
43991 int res2 = 0 ;
43992 PyObject * obj0 = 0 ;
43993 PyObject * obj1 = 0 ;
43994 char * kwnames[] = {
43995 (char *) "self",(char *) "handler", NULL
43996 };
43997
43998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44000 if (!SWIG_IsOK(res1)) {
44001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44002 }
44003 arg1 = reinterpret_cast< wxMenu * >(argp1);
44004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44005 if (!SWIG_IsOK(res2)) {
44006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44007 }
44008 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44009 {
44010 PyThreadState* __tstate = wxPyBeginAllowThreads();
44011 (arg1)->SetEventHandler(arg2);
44012 wxPyEndAllowThreads(__tstate);
44013 if (PyErr_Occurred()) SWIG_fail;
44014 }
44015 resultobj = SWIG_Py_Void();
44016 return resultobj;
44017 fail:
44018 return NULL;
44019 }
44020
44021
44022 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44023 PyObject *resultobj = 0;
44024 wxMenu *arg1 = (wxMenu *) 0 ;
44025 wxEvtHandler *result = 0 ;
44026 void *argp1 = 0 ;
44027 int res1 = 0 ;
44028 PyObject *swig_obj[1] ;
44029
44030 if (!args) SWIG_fail;
44031 swig_obj[0] = args;
44032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44033 if (!SWIG_IsOK(res1)) {
44034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44035 }
44036 arg1 = reinterpret_cast< wxMenu * >(argp1);
44037 {
44038 PyThreadState* __tstate = wxPyBeginAllowThreads();
44039 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44040 wxPyEndAllowThreads(__tstate);
44041 if (PyErr_Occurred()) SWIG_fail;
44042 }
44043 {
44044 resultobj = wxPyMake_wxObject(result, 0);
44045 }
44046 return resultobj;
44047 fail:
44048 return NULL;
44049 }
44050
44051
44052 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44053 PyObject *resultobj = 0;
44054 wxMenu *arg1 = (wxMenu *) 0 ;
44055 wxWindow *arg2 = (wxWindow *) 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 *) "win", NULL
44064 };
44065
44066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44068 if (!SWIG_IsOK(res1)) {
44069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44070 }
44071 arg1 = reinterpret_cast< wxMenu * >(argp1);
44072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44073 if (!SWIG_IsOK(res2)) {
44074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44075 }
44076 arg2 = reinterpret_cast< wxWindow * >(argp2);
44077 {
44078 PyThreadState* __tstate = wxPyBeginAllowThreads();
44079 (arg1)->SetInvokingWindow(arg2);
44080 wxPyEndAllowThreads(__tstate);
44081 if (PyErr_Occurred()) SWIG_fail;
44082 }
44083 resultobj = SWIG_Py_Void();
44084 return resultobj;
44085 fail:
44086 return NULL;
44087 }
44088
44089
44090 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44091 PyObject *resultobj = 0;
44092 wxMenu *arg1 = (wxMenu *) 0 ;
44093 wxWindow *result = 0 ;
44094 void *argp1 = 0 ;
44095 int res1 = 0 ;
44096 PyObject *swig_obj[1] ;
44097
44098 if (!args) SWIG_fail;
44099 swig_obj[0] = args;
44100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44101 if (!SWIG_IsOK(res1)) {
44102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44103 }
44104 arg1 = reinterpret_cast< wxMenu * >(argp1);
44105 {
44106 PyThreadState* __tstate = wxPyBeginAllowThreads();
44107 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44108 wxPyEndAllowThreads(__tstate);
44109 if (PyErr_Occurred()) SWIG_fail;
44110 }
44111 {
44112 resultobj = wxPyMake_wxObject(result, 0);
44113 }
44114 return resultobj;
44115 fail:
44116 return NULL;
44117 }
44118
44119
44120 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44121 PyObject *resultobj = 0;
44122 wxMenu *arg1 = (wxMenu *) 0 ;
44123 long result;
44124 void *argp1 = 0 ;
44125 int res1 = 0 ;
44126 PyObject *swig_obj[1] ;
44127
44128 if (!args) SWIG_fail;
44129 swig_obj[0] = args;
44130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44131 if (!SWIG_IsOK(res1)) {
44132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44133 }
44134 arg1 = reinterpret_cast< wxMenu * >(argp1);
44135 {
44136 PyThreadState* __tstate = wxPyBeginAllowThreads();
44137 result = (long)((wxMenu const *)arg1)->GetStyle();
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 resultobj = SWIG_From_long(static_cast< long >(result));
44142 return resultobj;
44143 fail:
44144 return NULL;
44145 }
44146
44147
44148 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44149 PyObject *resultobj = 0;
44150 wxMenu *arg1 = (wxMenu *) 0 ;
44151 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44152 void *argp1 = 0 ;
44153 int res1 = 0 ;
44154 void *argp2 = 0 ;
44155 int res2 = 0 ;
44156 PyObject * obj0 = 0 ;
44157 PyObject * obj1 = 0 ;
44158 char * kwnames[] = {
44159 (char *) "self",(char *) "source", NULL
44160 };
44161
44162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44164 if (!SWIG_IsOK(res1)) {
44165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44166 }
44167 arg1 = reinterpret_cast< wxMenu * >(argp1);
44168 if (obj1) {
44169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44170 if (!SWIG_IsOK(res2)) {
44171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44172 }
44173 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44174 }
44175 {
44176 PyThreadState* __tstate = wxPyBeginAllowThreads();
44177 (arg1)->UpdateUI(arg2);
44178 wxPyEndAllowThreads(__tstate);
44179 if (PyErr_Occurred()) SWIG_fail;
44180 }
44181 resultobj = SWIG_Py_Void();
44182 return resultobj;
44183 fail:
44184 return NULL;
44185 }
44186
44187
44188 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44189 PyObject *resultobj = 0;
44190 wxMenu *arg1 = (wxMenu *) 0 ;
44191 wxMenuBar *result = 0 ;
44192 void *argp1 = 0 ;
44193 int res1 = 0 ;
44194 PyObject *swig_obj[1] ;
44195
44196 if (!args) SWIG_fail;
44197 swig_obj[0] = args;
44198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44199 if (!SWIG_IsOK(res1)) {
44200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44201 }
44202 arg1 = reinterpret_cast< wxMenu * >(argp1);
44203 {
44204 PyThreadState* __tstate = wxPyBeginAllowThreads();
44205 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44206 wxPyEndAllowThreads(__tstate);
44207 if (PyErr_Occurred()) SWIG_fail;
44208 }
44209 {
44210 resultobj = wxPyMake_wxObject(result, (bool)0);
44211 }
44212 return resultobj;
44213 fail:
44214 return NULL;
44215 }
44216
44217
44218 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44219 PyObject *resultobj = 0;
44220 wxMenu *arg1 = (wxMenu *) 0 ;
44221 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44222 void *argp1 = 0 ;
44223 int res1 = 0 ;
44224 void *argp2 = 0 ;
44225 int res2 = 0 ;
44226 PyObject * obj0 = 0 ;
44227 PyObject * obj1 = 0 ;
44228 char * kwnames[] = {
44229 (char *) "self",(char *) "menubar", NULL
44230 };
44231
44232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44234 if (!SWIG_IsOK(res1)) {
44235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44236 }
44237 arg1 = reinterpret_cast< wxMenu * >(argp1);
44238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44239 if (!SWIG_IsOK(res2)) {
44240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44241 }
44242 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44243 {
44244 PyThreadState* __tstate = wxPyBeginAllowThreads();
44245 (arg1)->Attach(arg2);
44246 wxPyEndAllowThreads(__tstate);
44247 if (PyErr_Occurred()) SWIG_fail;
44248 }
44249 resultobj = SWIG_Py_Void();
44250 return resultobj;
44251 fail:
44252 return NULL;
44253 }
44254
44255
44256 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44257 PyObject *resultobj = 0;
44258 wxMenu *arg1 = (wxMenu *) 0 ;
44259 void *argp1 = 0 ;
44260 int res1 = 0 ;
44261 PyObject *swig_obj[1] ;
44262
44263 if (!args) SWIG_fail;
44264 swig_obj[0] = args;
44265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44266 if (!SWIG_IsOK(res1)) {
44267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44268 }
44269 arg1 = reinterpret_cast< wxMenu * >(argp1);
44270 {
44271 PyThreadState* __tstate = wxPyBeginAllowThreads();
44272 (arg1)->Detach();
44273 wxPyEndAllowThreads(__tstate);
44274 if (PyErr_Occurred()) SWIG_fail;
44275 }
44276 resultobj = SWIG_Py_Void();
44277 return resultobj;
44278 fail:
44279 return NULL;
44280 }
44281
44282
44283 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44284 PyObject *resultobj = 0;
44285 wxMenu *arg1 = (wxMenu *) 0 ;
44286 bool result;
44287 void *argp1 = 0 ;
44288 int res1 = 0 ;
44289 PyObject *swig_obj[1] ;
44290
44291 if (!args) SWIG_fail;
44292 swig_obj[0] = args;
44293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44294 if (!SWIG_IsOK(res1)) {
44295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44296 }
44297 arg1 = reinterpret_cast< wxMenu * >(argp1);
44298 {
44299 PyThreadState* __tstate = wxPyBeginAllowThreads();
44300 result = (bool)((wxMenu const *)arg1)->IsAttached();
44301 wxPyEndAllowThreads(__tstate);
44302 if (PyErr_Occurred()) SWIG_fail;
44303 }
44304 {
44305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44306 }
44307 return resultobj;
44308 fail:
44309 return NULL;
44310 }
44311
44312
44313 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44314 PyObject *resultobj = 0;
44315 wxMenu *arg1 = (wxMenu *) 0 ;
44316 wxMenu *arg2 = (wxMenu *) 0 ;
44317 void *argp1 = 0 ;
44318 int res1 = 0 ;
44319 void *argp2 = 0 ;
44320 int res2 = 0 ;
44321 PyObject * obj0 = 0 ;
44322 PyObject * obj1 = 0 ;
44323 char * kwnames[] = {
44324 (char *) "self",(char *) "parent", NULL
44325 };
44326
44327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44329 if (!SWIG_IsOK(res1)) {
44330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44331 }
44332 arg1 = reinterpret_cast< wxMenu * >(argp1);
44333 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44334 if (!SWIG_IsOK(res2)) {
44335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44336 }
44337 arg2 = reinterpret_cast< wxMenu * >(argp2);
44338 {
44339 PyThreadState* __tstate = wxPyBeginAllowThreads();
44340 (arg1)->SetParent(arg2);
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 resultobj = SWIG_Py_Void();
44345 return resultobj;
44346 fail:
44347 return NULL;
44348 }
44349
44350
44351 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44352 PyObject *resultobj = 0;
44353 wxMenu *arg1 = (wxMenu *) 0 ;
44354 wxMenu *result = 0 ;
44355 void *argp1 = 0 ;
44356 int res1 = 0 ;
44357 PyObject *swig_obj[1] ;
44358
44359 if (!args) SWIG_fail;
44360 swig_obj[0] = args;
44361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44362 if (!SWIG_IsOK(res1)) {
44363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44364 }
44365 arg1 = reinterpret_cast< wxMenu * >(argp1);
44366 {
44367 PyThreadState* __tstate = wxPyBeginAllowThreads();
44368 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44369 wxPyEndAllowThreads(__tstate);
44370 if (PyErr_Occurred()) SWIG_fail;
44371 }
44372 {
44373 resultobj = wxPyMake_wxObject(result, 0);
44374 }
44375 return resultobj;
44376 fail:
44377 return NULL;
44378 }
44379
44380
44381 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44382 PyObject *obj;
44383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44384 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44385 return SWIG_Py_Void();
44386 }
44387
44388 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44389 return SWIG_Python_InitShadowInstance(args);
44390 }
44391
44392 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44393 PyObject *resultobj = 0;
44394 long arg1 = (long) 0 ;
44395 wxMenuBar *result = 0 ;
44396 long val1 ;
44397 int ecode1 = 0 ;
44398 PyObject * obj0 = 0 ;
44399 char * kwnames[] = {
44400 (char *) "style", NULL
44401 };
44402
44403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44404 if (obj0) {
44405 ecode1 = SWIG_AsVal_long(obj0, &val1);
44406 if (!SWIG_IsOK(ecode1)) {
44407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44408 }
44409 arg1 = static_cast< long >(val1);
44410 }
44411 {
44412 if (!wxPyCheckForApp()) SWIG_fail;
44413 PyThreadState* __tstate = wxPyBeginAllowThreads();
44414 result = (wxMenuBar *)new wxMenuBar(arg1);
44415 wxPyEndAllowThreads(__tstate);
44416 if (PyErr_Occurred()) SWIG_fail;
44417 }
44418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44419 return resultobj;
44420 fail:
44421 return NULL;
44422 }
44423
44424
44425 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44426 PyObject *resultobj = 0;
44427 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44428 wxMenu *arg2 = (wxMenu *) 0 ;
44429 wxString *arg3 = 0 ;
44430 bool result;
44431 void *argp1 = 0 ;
44432 int res1 = 0 ;
44433 void *argp2 = 0 ;
44434 int res2 = 0 ;
44435 bool temp3 = false ;
44436 PyObject * obj0 = 0 ;
44437 PyObject * obj1 = 0 ;
44438 PyObject * obj2 = 0 ;
44439 char * kwnames[] = {
44440 (char *) "self",(char *) "menu",(char *) "title", NULL
44441 };
44442
44443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44445 if (!SWIG_IsOK(res1)) {
44446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44447 }
44448 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44450 if (!SWIG_IsOK(res2)) {
44451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44452 }
44453 arg2 = reinterpret_cast< wxMenu * >(argp2);
44454 {
44455 arg3 = wxString_in_helper(obj2);
44456 if (arg3 == NULL) SWIG_fail;
44457 temp3 = true;
44458 }
44459 {
44460 PyThreadState* __tstate = wxPyBeginAllowThreads();
44461 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44462 wxPyEndAllowThreads(__tstate);
44463 if (PyErr_Occurred()) SWIG_fail;
44464 }
44465 {
44466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44467 }
44468 {
44469 if (temp3)
44470 delete arg3;
44471 }
44472 return resultobj;
44473 fail:
44474 {
44475 if (temp3)
44476 delete arg3;
44477 }
44478 return NULL;
44479 }
44480
44481
44482 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44483 PyObject *resultobj = 0;
44484 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44485 size_t arg2 ;
44486 wxMenu *arg3 = (wxMenu *) 0 ;
44487 wxString *arg4 = 0 ;
44488 bool result;
44489 void *argp1 = 0 ;
44490 int res1 = 0 ;
44491 size_t val2 ;
44492 int ecode2 = 0 ;
44493 void *argp3 = 0 ;
44494 int res3 = 0 ;
44495 bool temp4 = false ;
44496 PyObject * obj0 = 0 ;
44497 PyObject * obj1 = 0 ;
44498 PyObject * obj2 = 0 ;
44499 PyObject * obj3 = 0 ;
44500 char * kwnames[] = {
44501 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44502 };
44503
44504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44506 if (!SWIG_IsOK(res1)) {
44507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44508 }
44509 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44510 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44511 if (!SWIG_IsOK(ecode2)) {
44512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44513 }
44514 arg2 = static_cast< size_t >(val2);
44515 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44516 if (!SWIG_IsOK(res3)) {
44517 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44518 }
44519 arg3 = reinterpret_cast< wxMenu * >(argp3);
44520 {
44521 arg4 = wxString_in_helper(obj3);
44522 if (arg4 == NULL) SWIG_fail;
44523 temp4 = true;
44524 }
44525 {
44526 PyThreadState* __tstate = wxPyBeginAllowThreads();
44527 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44528 wxPyEndAllowThreads(__tstate);
44529 if (PyErr_Occurred()) SWIG_fail;
44530 }
44531 {
44532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44533 }
44534 {
44535 if (temp4)
44536 delete arg4;
44537 }
44538 return resultobj;
44539 fail:
44540 {
44541 if (temp4)
44542 delete arg4;
44543 }
44544 return NULL;
44545 }
44546
44547
44548 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44549 PyObject *resultobj = 0;
44550 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44551 size_t result;
44552 void *argp1 = 0 ;
44553 int res1 = 0 ;
44554 PyObject *swig_obj[1] ;
44555
44556 if (!args) SWIG_fail;
44557 swig_obj[0] = args;
44558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44559 if (!SWIG_IsOK(res1)) {
44560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44561 }
44562 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44563 {
44564 PyThreadState* __tstate = wxPyBeginAllowThreads();
44565 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44566 wxPyEndAllowThreads(__tstate);
44567 if (PyErr_Occurred()) SWIG_fail;
44568 }
44569 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44570 return resultobj;
44571 fail:
44572 return NULL;
44573 }
44574
44575
44576 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44577 PyObject *resultobj = 0;
44578 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44579 size_t arg2 ;
44580 wxMenu *result = 0 ;
44581 void *argp1 = 0 ;
44582 int res1 = 0 ;
44583 size_t val2 ;
44584 int ecode2 = 0 ;
44585 PyObject * obj0 = 0 ;
44586 PyObject * obj1 = 0 ;
44587 char * kwnames[] = {
44588 (char *) "self",(char *) "pos", NULL
44589 };
44590
44591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44593 if (!SWIG_IsOK(res1)) {
44594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44595 }
44596 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44597 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44598 if (!SWIG_IsOK(ecode2)) {
44599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44600 }
44601 arg2 = static_cast< size_t >(val2);
44602 {
44603 PyThreadState* __tstate = wxPyBeginAllowThreads();
44604 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44605 wxPyEndAllowThreads(__tstate);
44606 if (PyErr_Occurred()) SWIG_fail;
44607 }
44608 {
44609 resultobj = wxPyMake_wxObject(result, 0);
44610 }
44611 return resultobj;
44612 fail:
44613 return NULL;
44614 }
44615
44616
44617 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44618 PyObject *resultobj = 0;
44619 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44620 size_t arg2 ;
44621 wxMenu *arg3 = (wxMenu *) 0 ;
44622 wxString *arg4 = 0 ;
44623 wxMenu *result = 0 ;
44624 void *argp1 = 0 ;
44625 int res1 = 0 ;
44626 size_t val2 ;
44627 int ecode2 = 0 ;
44628 void *argp3 = 0 ;
44629 int res3 = 0 ;
44630 bool temp4 = false ;
44631 PyObject * obj0 = 0 ;
44632 PyObject * obj1 = 0 ;
44633 PyObject * obj2 = 0 ;
44634 PyObject * obj3 = 0 ;
44635 char * kwnames[] = {
44636 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44637 };
44638
44639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44641 if (!SWIG_IsOK(res1)) {
44642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44643 }
44644 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44645 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44646 if (!SWIG_IsOK(ecode2)) {
44647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44648 }
44649 arg2 = static_cast< size_t >(val2);
44650 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44651 if (!SWIG_IsOK(res3)) {
44652 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44653 }
44654 arg3 = reinterpret_cast< wxMenu * >(argp3);
44655 {
44656 arg4 = wxString_in_helper(obj3);
44657 if (arg4 == NULL) SWIG_fail;
44658 temp4 = true;
44659 }
44660 {
44661 PyThreadState* __tstate = wxPyBeginAllowThreads();
44662 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44663 wxPyEndAllowThreads(__tstate);
44664 if (PyErr_Occurred()) SWIG_fail;
44665 }
44666 {
44667 resultobj = wxPyMake_wxObject(result, 0);
44668 }
44669 {
44670 if (temp4)
44671 delete arg4;
44672 }
44673 return resultobj;
44674 fail:
44675 {
44676 if (temp4)
44677 delete arg4;
44678 }
44679 return NULL;
44680 }
44681
44682
44683 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44684 PyObject *resultobj = 0;
44685 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44686 size_t arg2 ;
44687 wxMenu *result = 0 ;
44688 void *argp1 = 0 ;
44689 int res1 = 0 ;
44690 size_t val2 ;
44691 int ecode2 = 0 ;
44692 PyObject * obj0 = 0 ;
44693 PyObject * obj1 = 0 ;
44694 char * kwnames[] = {
44695 (char *) "self",(char *) "pos", NULL
44696 };
44697
44698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44700 if (!SWIG_IsOK(res1)) {
44701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44702 }
44703 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44704 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44705 if (!SWIG_IsOK(ecode2)) {
44706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44707 }
44708 arg2 = static_cast< size_t >(val2);
44709 {
44710 PyThreadState* __tstate = wxPyBeginAllowThreads();
44711 result = (wxMenu *)(arg1)->Remove(arg2);
44712 wxPyEndAllowThreads(__tstate);
44713 if (PyErr_Occurred()) SWIG_fail;
44714 }
44715 {
44716 resultobj = wxPyMake_wxObject(result, 0);
44717 }
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44725 PyObject *resultobj = 0;
44726 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44727 size_t arg2 ;
44728 bool arg3 ;
44729 void *argp1 = 0 ;
44730 int res1 = 0 ;
44731 size_t val2 ;
44732 int ecode2 = 0 ;
44733 bool val3 ;
44734 int ecode3 = 0 ;
44735 PyObject * obj0 = 0 ;
44736 PyObject * obj1 = 0 ;
44737 PyObject * obj2 = 0 ;
44738 char * kwnames[] = {
44739 (char *) "self",(char *) "pos",(char *) "enable", NULL
44740 };
44741
44742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44744 if (!SWIG_IsOK(res1)) {
44745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44746 }
44747 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44748 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44749 if (!SWIG_IsOK(ecode2)) {
44750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44751 }
44752 arg2 = static_cast< size_t >(val2);
44753 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44754 if (!SWIG_IsOK(ecode3)) {
44755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44756 }
44757 arg3 = static_cast< bool >(val3);
44758 {
44759 PyThreadState* __tstate = wxPyBeginAllowThreads();
44760 (arg1)->EnableTop(arg2,arg3);
44761 wxPyEndAllowThreads(__tstate);
44762 if (PyErr_Occurred()) SWIG_fail;
44763 }
44764 resultobj = SWIG_Py_Void();
44765 return resultobj;
44766 fail:
44767 return NULL;
44768 }
44769
44770
44771 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44772 PyObject *resultobj = 0;
44773 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44774 size_t arg2 ;
44775 bool result;
44776 void *argp1 = 0 ;
44777 int res1 = 0 ;
44778 size_t val2 ;
44779 int ecode2 = 0 ;
44780 PyObject * obj0 = 0 ;
44781 PyObject * obj1 = 0 ;
44782 char * kwnames[] = {
44783 (char *) "self",(char *) "pos", NULL
44784 };
44785
44786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44788 if (!SWIG_IsOK(res1)) {
44789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44790 }
44791 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44792 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44793 if (!SWIG_IsOK(ecode2)) {
44794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44795 }
44796 arg2 = static_cast< size_t >(val2);
44797 {
44798 PyThreadState* __tstate = wxPyBeginAllowThreads();
44799 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44800 wxPyEndAllowThreads(__tstate);
44801 if (PyErr_Occurred()) SWIG_fail;
44802 }
44803 {
44804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44805 }
44806 return resultobj;
44807 fail:
44808 return NULL;
44809 }
44810
44811
44812 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44813 PyObject *resultobj = 0;
44814 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44815 size_t arg2 ;
44816 wxString *arg3 = 0 ;
44817 void *argp1 = 0 ;
44818 int res1 = 0 ;
44819 size_t val2 ;
44820 int ecode2 = 0 ;
44821 bool temp3 = false ;
44822 PyObject * obj0 = 0 ;
44823 PyObject * obj1 = 0 ;
44824 PyObject * obj2 = 0 ;
44825 char * kwnames[] = {
44826 (char *) "self",(char *) "pos",(char *) "label", NULL
44827 };
44828
44829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44831 if (!SWIG_IsOK(res1)) {
44832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44833 }
44834 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44835 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44836 if (!SWIG_IsOK(ecode2)) {
44837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44838 }
44839 arg2 = static_cast< size_t >(val2);
44840 {
44841 arg3 = wxString_in_helper(obj2);
44842 if (arg3 == NULL) SWIG_fail;
44843 temp3 = true;
44844 }
44845 {
44846 PyThreadState* __tstate = wxPyBeginAllowThreads();
44847 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44848 wxPyEndAllowThreads(__tstate);
44849 if (PyErr_Occurred()) SWIG_fail;
44850 }
44851 resultobj = SWIG_Py_Void();
44852 {
44853 if (temp3)
44854 delete arg3;
44855 }
44856 return resultobj;
44857 fail:
44858 {
44859 if (temp3)
44860 delete arg3;
44861 }
44862 return NULL;
44863 }
44864
44865
44866 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44867 PyObject *resultobj = 0;
44868 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44869 size_t arg2 ;
44870 wxString result;
44871 void *argp1 = 0 ;
44872 int res1 = 0 ;
44873 size_t val2 ;
44874 int ecode2 = 0 ;
44875 PyObject * obj0 = 0 ;
44876 PyObject * obj1 = 0 ;
44877 char * kwnames[] = {
44878 (char *) "self",(char *) "pos", NULL
44879 };
44880
44881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44883 if (!SWIG_IsOK(res1)) {
44884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44885 }
44886 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44887 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44888 if (!SWIG_IsOK(ecode2)) {
44889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44890 }
44891 arg2 = static_cast< size_t >(val2);
44892 {
44893 PyThreadState* __tstate = wxPyBeginAllowThreads();
44894 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44895 wxPyEndAllowThreads(__tstate);
44896 if (PyErr_Occurred()) SWIG_fail;
44897 }
44898 {
44899 #if wxUSE_UNICODE
44900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44901 #else
44902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44903 #endif
44904 }
44905 return resultobj;
44906 fail:
44907 return NULL;
44908 }
44909
44910
44911 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44912 PyObject *resultobj = 0;
44913 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44914 wxString *arg2 = 0 ;
44915 wxString *arg3 = 0 ;
44916 int result;
44917 void *argp1 = 0 ;
44918 int res1 = 0 ;
44919 bool temp2 = false ;
44920 bool temp3 = false ;
44921 PyObject * obj0 = 0 ;
44922 PyObject * obj1 = 0 ;
44923 PyObject * obj2 = 0 ;
44924 char * kwnames[] = {
44925 (char *) "self",(char *) "menu",(char *) "item", NULL
44926 };
44927
44928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44930 if (!SWIG_IsOK(res1)) {
44931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44932 }
44933 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44934 {
44935 arg2 = wxString_in_helper(obj1);
44936 if (arg2 == NULL) SWIG_fail;
44937 temp2 = true;
44938 }
44939 {
44940 arg3 = wxString_in_helper(obj2);
44941 if (arg3 == NULL) SWIG_fail;
44942 temp3 = true;
44943 }
44944 {
44945 PyThreadState* __tstate = wxPyBeginAllowThreads();
44946 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44947 wxPyEndAllowThreads(__tstate);
44948 if (PyErr_Occurred()) SWIG_fail;
44949 }
44950 resultobj = SWIG_From_int(static_cast< int >(result));
44951 {
44952 if (temp2)
44953 delete arg2;
44954 }
44955 {
44956 if (temp3)
44957 delete arg3;
44958 }
44959 return resultobj;
44960 fail:
44961 {
44962 if (temp2)
44963 delete arg2;
44964 }
44965 {
44966 if (temp3)
44967 delete arg3;
44968 }
44969 return NULL;
44970 }
44971
44972
44973 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44974 PyObject *resultobj = 0;
44975 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44976 int arg2 ;
44977 wxMenuItem *result = 0 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 int val2 ;
44981 int ecode2 = 0 ;
44982 PyObject * obj0 = 0 ;
44983 PyObject * obj1 = 0 ;
44984 char * kwnames[] = {
44985 (char *) "self",(char *) "id", NULL
44986 };
44987
44988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44990 if (!SWIG_IsOK(res1)) {
44991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44992 }
44993 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44994 ecode2 = SWIG_AsVal_int(obj1, &val2);
44995 if (!SWIG_IsOK(ecode2)) {
44996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44997 }
44998 arg2 = static_cast< int >(val2);
44999 {
45000 PyThreadState* __tstate = wxPyBeginAllowThreads();
45001 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45002 wxPyEndAllowThreads(__tstate);
45003 if (PyErr_Occurred()) SWIG_fail;
45004 }
45005 {
45006 resultobj = wxPyMake_wxObject(result, (bool)0);
45007 }
45008 return resultobj;
45009 fail:
45010 return NULL;
45011 }
45012
45013
45014 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45015 PyObject *resultobj = 0;
45016 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45017 wxString *arg2 = 0 ;
45018 int result;
45019 void *argp1 = 0 ;
45020 int res1 = 0 ;
45021 bool temp2 = false ;
45022 PyObject * obj0 = 0 ;
45023 PyObject * obj1 = 0 ;
45024 char * kwnames[] = {
45025 (char *) "self",(char *) "title", NULL
45026 };
45027
45028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45030 if (!SWIG_IsOK(res1)) {
45031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45032 }
45033 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45034 {
45035 arg2 = wxString_in_helper(obj1);
45036 if (arg2 == NULL) SWIG_fail;
45037 temp2 = true;
45038 }
45039 {
45040 PyThreadState* __tstate = wxPyBeginAllowThreads();
45041 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45042 wxPyEndAllowThreads(__tstate);
45043 if (PyErr_Occurred()) SWIG_fail;
45044 }
45045 resultobj = SWIG_From_int(static_cast< int >(result));
45046 {
45047 if (temp2)
45048 delete arg2;
45049 }
45050 return resultobj;
45051 fail:
45052 {
45053 if (temp2)
45054 delete arg2;
45055 }
45056 return NULL;
45057 }
45058
45059
45060 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45061 PyObject *resultobj = 0;
45062 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45063 int arg2 ;
45064 bool arg3 ;
45065 void *argp1 = 0 ;
45066 int res1 = 0 ;
45067 int val2 ;
45068 int ecode2 = 0 ;
45069 bool val3 ;
45070 int ecode3 = 0 ;
45071 PyObject * obj0 = 0 ;
45072 PyObject * obj1 = 0 ;
45073 PyObject * obj2 = 0 ;
45074 char * kwnames[] = {
45075 (char *) "self",(char *) "id",(char *) "enable", NULL
45076 };
45077
45078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45080 if (!SWIG_IsOK(res1)) {
45081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45082 }
45083 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45084 ecode2 = SWIG_AsVal_int(obj1, &val2);
45085 if (!SWIG_IsOK(ecode2)) {
45086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45087 }
45088 arg2 = static_cast< int >(val2);
45089 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45090 if (!SWIG_IsOK(ecode3)) {
45091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45092 }
45093 arg3 = static_cast< bool >(val3);
45094 {
45095 PyThreadState* __tstate = wxPyBeginAllowThreads();
45096 (arg1)->Enable(arg2,arg3);
45097 wxPyEndAllowThreads(__tstate);
45098 if (PyErr_Occurred()) SWIG_fail;
45099 }
45100 resultobj = SWIG_Py_Void();
45101 return resultobj;
45102 fail:
45103 return NULL;
45104 }
45105
45106
45107 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45108 PyObject *resultobj = 0;
45109 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45110 int arg2 ;
45111 bool arg3 ;
45112 void *argp1 = 0 ;
45113 int res1 = 0 ;
45114 int val2 ;
45115 int ecode2 = 0 ;
45116 bool val3 ;
45117 int ecode3 = 0 ;
45118 PyObject * obj0 = 0 ;
45119 PyObject * obj1 = 0 ;
45120 PyObject * obj2 = 0 ;
45121 char * kwnames[] = {
45122 (char *) "self",(char *) "id",(char *) "check", NULL
45123 };
45124
45125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45127 if (!SWIG_IsOK(res1)) {
45128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45129 }
45130 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45131 ecode2 = SWIG_AsVal_int(obj1, &val2);
45132 if (!SWIG_IsOK(ecode2)) {
45133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45134 }
45135 arg2 = static_cast< int >(val2);
45136 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45137 if (!SWIG_IsOK(ecode3)) {
45138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45139 }
45140 arg3 = static_cast< bool >(val3);
45141 {
45142 PyThreadState* __tstate = wxPyBeginAllowThreads();
45143 (arg1)->Check(arg2,arg3);
45144 wxPyEndAllowThreads(__tstate);
45145 if (PyErr_Occurred()) SWIG_fail;
45146 }
45147 resultobj = SWIG_Py_Void();
45148 return resultobj;
45149 fail:
45150 return NULL;
45151 }
45152
45153
45154 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45155 PyObject *resultobj = 0;
45156 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45157 int arg2 ;
45158 bool result;
45159 void *argp1 = 0 ;
45160 int res1 = 0 ;
45161 int val2 ;
45162 int ecode2 = 0 ;
45163 PyObject * obj0 = 0 ;
45164 PyObject * obj1 = 0 ;
45165 char * kwnames[] = {
45166 (char *) "self",(char *) "id", NULL
45167 };
45168
45169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45171 if (!SWIG_IsOK(res1)) {
45172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45173 }
45174 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45175 ecode2 = SWIG_AsVal_int(obj1, &val2);
45176 if (!SWIG_IsOK(ecode2)) {
45177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45178 }
45179 arg2 = static_cast< int >(val2);
45180 {
45181 PyThreadState* __tstate = wxPyBeginAllowThreads();
45182 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45183 wxPyEndAllowThreads(__tstate);
45184 if (PyErr_Occurred()) SWIG_fail;
45185 }
45186 {
45187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45188 }
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45196 PyObject *resultobj = 0;
45197 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45198 int arg2 ;
45199 bool result;
45200 void *argp1 = 0 ;
45201 int res1 = 0 ;
45202 int val2 ;
45203 int ecode2 = 0 ;
45204 PyObject * obj0 = 0 ;
45205 PyObject * obj1 = 0 ;
45206 char * kwnames[] = {
45207 (char *) "self",(char *) "id", NULL
45208 };
45209
45210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45212 if (!SWIG_IsOK(res1)) {
45213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45214 }
45215 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45216 ecode2 = SWIG_AsVal_int(obj1, &val2);
45217 if (!SWIG_IsOK(ecode2)) {
45218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45219 }
45220 arg2 = static_cast< int >(val2);
45221 {
45222 PyThreadState* __tstate = wxPyBeginAllowThreads();
45223 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45224 wxPyEndAllowThreads(__tstate);
45225 if (PyErr_Occurred()) SWIG_fail;
45226 }
45227 {
45228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45229 }
45230 return resultobj;
45231 fail:
45232 return NULL;
45233 }
45234
45235
45236 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45237 PyObject *resultobj = 0;
45238 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45239 int arg2 ;
45240 wxString *arg3 = 0 ;
45241 void *argp1 = 0 ;
45242 int res1 = 0 ;
45243 int val2 ;
45244 int ecode2 = 0 ;
45245 bool temp3 = false ;
45246 PyObject * obj0 = 0 ;
45247 PyObject * obj1 = 0 ;
45248 PyObject * obj2 = 0 ;
45249 char * kwnames[] = {
45250 (char *) "self",(char *) "id",(char *) "label", NULL
45251 };
45252
45253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45255 if (!SWIG_IsOK(res1)) {
45256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45257 }
45258 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45259 ecode2 = SWIG_AsVal_int(obj1, &val2);
45260 if (!SWIG_IsOK(ecode2)) {
45261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45262 }
45263 arg2 = static_cast< int >(val2);
45264 {
45265 arg3 = wxString_in_helper(obj2);
45266 if (arg3 == NULL) SWIG_fail;
45267 temp3 = true;
45268 }
45269 {
45270 PyThreadState* __tstate = wxPyBeginAllowThreads();
45271 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45272 wxPyEndAllowThreads(__tstate);
45273 if (PyErr_Occurred()) SWIG_fail;
45274 }
45275 resultobj = SWIG_Py_Void();
45276 {
45277 if (temp3)
45278 delete arg3;
45279 }
45280 return resultobj;
45281 fail:
45282 {
45283 if (temp3)
45284 delete arg3;
45285 }
45286 return NULL;
45287 }
45288
45289
45290 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45291 PyObject *resultobj = 0;
45292 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45293 int arg2 ;
45294 wxString result;
45295 void *argp1 = 0 ;
45296 int res1 = 0 ;
45297 int val2 ;
45298 int ecode2 = 0 ;
45299 PyObject * obj0 = 0 ;
45300 PyObject * obj1 = 0 ;
45301 char * kwnames[] = {
45302 (char *) "self",(char *) "id", NULL
45303 };
45304
45305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45307 if (!SWIG_IsOK(res1)) {
45308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45309 }
45310 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45311 ecode2 = SWIG_AsVal_int(obj1, &val2);
45312 if (!SWIG_IsOK(ecode2)) {
45313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45314 }
45315 arg2 = static_cast< int >(val2);
45316 {
45317 PyThreadState* __tstate = wxPyBeginAllowThreads();
45318 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45319 wxPyEndAllowThreads(__tstate);
45320 if (PyErr_Occurred()) SWIG_fail;
45321 }
45322 {
45323 #if wxUSE_UNICODE
45324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45325 #else
45326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45327 #endif
45328 }
45329 return resultobj;
45330 fail:
45331 return NULL;
45332 }
45333
45334
45335 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45336 PyObject *resultobj = 0;
45337 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45338 int arg2 ;
45339 wxString *arg3 = 0 ;
45340 void *argp1 = 0 ;
45341 int res1 = 0 ;
45342 int val2 ;
45343 int ecode2 = 0 ;
45344 bool temp3 = false ;
45345 PyObject * obj0 = 0 ;
45346 PyObject * obj1 = 0 ;
45347 PyObject * obj2 = 0 ;
45348 char * kwnames[] = {
45349 (char *) "self",(char *) "id",(char *) "helpString", NULL
45350 };
45351
45352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45354 if (!SWIG_IsOK(res1)) {
45355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45356 }
45357 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45358 ecode2 = SWIG_AsVal_int(obj1, &val2);
45359 if (!SWIG_IsOK(ecode2)) {
45360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45361 }
45362 arg2 = static_cast< int >(val2);
45363 {
45364 arg3 = wxString_in_helper(obj2);
45365 if (arg3 == NULL) SWIG_fail;
45366 temp3 = true;
45367 }
45368 {
45369 PyThreadState* __tstate = wxPyBeginAllowThreads();
45370 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45371 wxPyEndAllowThreads(__tstate);
45372 if (PyErr_Occurred()) SWIG_fail;
45373 }
45374 resultobj = SWIG_Py_Void();
45375 {
45376 if (temp3)
45377 delete arg3;
45378 }
45379 return resultobj;
45380 fail:
45381 {
45382 if (temp3)
45383 delete arg3;
45384 }
45385 return NULL;
45386 }
45387
45388
45389 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45390 PyObject *resultobj = 0;
45391 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45392 int arg2 ;
45393 wxString result;
45394 void *argp1 = 0 ;
45395 int res1 = 0 ;
45396 int val2 ;
45397 int ecode2 = 0 ;
45398 PyObject * obj0 = 0 ;
45399 PyObject * obj1 = 0 ;
45400 char * kwnames[] = {
45401 (char *) "self",(char *) "id", NULL
45402 };
45403
45404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45406 if (!SWIG_IsOK(res1)) {
45407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45408 }
45409 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45410 ecode2 = SWIG_AsVal_int(obj1, &val2);
45411 if (!SWIG_IsOK(ecode2)) {
45412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45413 }
45414 arg2 = static_cast< int >(val2);
45415 {
45416 PyThreadState* __tstate = wxPyBeginAllowThreads();
45417 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45418 wxPyEndAllowThreads(__tstate);
45419 if (PyErr_Occurred()) SWIG_fail;
45420 }
45421 {
45422 #if wxUSE_UNICODE
45423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45424 #else
45425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45426 #endif
45427 }
45428 return resultobj;
45429 fail:
45430 return NULL;
45431 }
45432
45433
45434 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45435 PyObject *resultobj = 0;
45436 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45437 wxFrame *result = 0 ;
45438 void *argp1 = 0 ;
45439 int res1 = 0 ;
45440 PyObject *swig_obj[1] ;
45441
45442 if (!args) SWIG_fail;
45443 swig_obj[0] = args;
45444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45445 if (!SWIG_IsOK(res1)) {
45446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45447 }
45448 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45449 {
45450 PyThreadState* __tstate = wxPyBeginAllowThreads();
45451 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45452 wxPyEndAllowThreads(__tstate);
45453 if (PyErr_Occurred()) SWIG_fail;
45454 }
45455 {
45456 resultobj = wxPyMake_wxObject(result, (bool)0);
45457 }
45458 return resultobj;
45459 fail:
45460 return NULL;
45461 }
45462
45463
45464 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45465 PyObject *resultobj = 0;
45466 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45467 bool result;
45468 void *argp1 = 0 ;
45469 int res1 = 0 ;
45470 PyObject *swig_obj[1] ;
45471
45472 if (!args) SWIG_fail;
45473 swig_obj[0] = args;
45474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45475 if (!SWIG_IsOK(res1)) {
45476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45477 }
45478 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45479 {
45480 PyThreadState* __tstate = wxPyBeginAllowThreads();
45481 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45482 wxPyEndAllowThreads(__tstate);
45483 if (PyErr_Occurred()) SWIG_fail;
45484 }
45485 {
45486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45487 }
45488 return resultobj;
45489 fail:
45490 return NULL;
45491 }
45492
45493
45494 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45495 PyObject *resultobj = 0;
45496 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45497 wxFrame *arg2 = (wxFrame *) 0 ;
45498 void *argp1 = 0 ;
45499 int res1 = 0 ;
45500 void *argp2 = 0 ;
45501 int res2 = 0 ;
45502 PyObject * obj0 = 0 ;
45503 PyObject * obj1 = 0 ;
45504 char * kwnames[] = {
45505 (char *) "self",(char *) "frame", NULL
45506 };
45507
45508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45510 if (!SWIG_IsOK(res1)) {
45511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45512 }
45513 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45514 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45515 if (!SWIG_IsOK(res2)) {
45516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45517 }
45518 arg2 = reinterpret_cast< wxFrame * >(argp2);
45519 {
45520 PyThreadState* __tstate = wxPyBeginAllowThreads();
45521 (arg1)->Attach(arg2);
45522 wxPyEndAllowThreads(__tstate);
45523 if (PyErr_Occurred()) SWIG_fail;
45524 }
45525 resultobj = SWIG_Py_Void();
45526 return resultobj;
45527 fail:
45528 return NULL;
45529 }
45530
45531
45532 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45533 PyObject *resultobj = 0;
45534 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45535 void *argp1 = 0 ;
45536 int res1 = 0 ;
45537 PyObject *swig_obj[1] ;
45538
45539 if (!args) SWIG_fail;
45540 swig_obj[0] = args;
45541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45542 if (!SWIG_IsOK(res1)) {
45543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45544 }
45545 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45546 {
45547 PyThreadState* __tstate = wxPyBeginAllowThreads();
45548 (arg1)->Detach();
45549 wxPyEndAllowThreads(__tstate);
45550 if (PyErr_Occurred()) SWIG_fail;
45551 }
45552 resultobj = SWIG_Py_Void();
45553 return resultobj;
45554 fail:
45555 return NULL;
45556 }
45557
45558
45559 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45560 PyObject *resultobj = 0;
45561 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45562 void *argp1 = 0 ;
45563 int res1 = 0 ;
45564 PyObject *swig_obj[1] ;
45565
45566 if (!args) SWIG_fail;
45567 swig_obj[0] = args;
45568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45569 if (!SWIG_IsOK(res1)) {
45570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45571 }
45572 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45573 {
45574 PyThreadState* __tstate = wxPyBeginAllowThreads();
45575 (arg1)->UpdateMenus();
45576 wxPyEndAllowThreads(__tstate);
45577 if (PyErr_Occurred()) SWIG_fail;
45578 }
45579 resultobj = SWIG_Py_Void();
45580 return resultobj;
45581 fail:
45582 return NULL;
45583 }
45584
45585
45586 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45587 PyObject *resultobj = 0;
45588 bool arg1 ;
45589 bool val1 ;
45590 int ecode1 = 0 ;
45591 PyObject * obj0 = 0 ;
45592 char * kwnames[] = {
45593 (char *) "enable", NULL
45594 };
45595
45596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45597 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45598 if (!SWIG_IsOK(ecode1)) {
45599 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45600 }
45601 arg1 = static_cast< bool >(val1);
45602 {
45603 PyThreadState* __tstate = wxPyBeginAllowThreads();
45604 wxMenuBar_SetAutoWindowMenu(arg1);
45605 wxPyEndAllowThreads(__tstate);
45606 if (PyErr_Occurred()) SWIG_fail;
45607 }
45608 resultobj = SWIG_Py_Void();
45609 return resultobj;
45610 fail:
45611 return NULL;
45612 }
45613
45614
45615 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45616 PyObject *resultobj = 0;
45617 bool result;
45618
45619 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45620 {
45621 PyThreadState* __tstate = wxPyBeginAllowThreads();
45622 result = (bool)wxMenuBar_GetAutoWindowMenu();
45623 wxPyEndAllowThreads(__tstate);
45624 if (PyErr_Occurred()) SWIG_fail;
45625 }
45626 {
45627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45628 }
45629 return resultobj;
45630 fail:
45631 return NULL;
45632 }
45633
45634
45635 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45636 PyObject *obj;
45637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45638 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45639 return SWIG_Py_Void();
45640 }
45641
45642 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45643 return SWIG_Python_InitShadowInstance(args);
45644 }
45645
45646 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45647 PyObject *resultobj = 0;
45648 wxMenu *arg1 = (wxMenu *) NULL ;
45649 int arg2 = (int) wxID_ANY ;
45650 wxString const &arg3_defvalue = wxPyEmptyString ;
45651 wxString *arg3 = (wxString *) &arg3_defvalue ;
45652 wxString const &arg4_defvalue = wxPyEmptyString ;
45653 wxString *arg4 = (wxString *) &arg4_defvalue ;
45654 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45655 wxMenu *arg6 = (wxMenu *) NULL ;
45656 wxMenuItem *result = 0 ;
45657 void *argp1 = 0 ;
45658 int res1 = 0 ;
45659 int val2 ;
45660 int ecode2 = 0 ;
45661 bool temp3 = false ;
45662 bool temp4 = false ;
45663 int val5 ;
45664 int ecode5 = 0 ;
45665 void *argp6 = 0 ;
45666 int res6 = 0 ;
45667 PyObject * obj0 = 0 ;
45668 PyObject * obj1 = 0 ;
45669 PyObject * obj2 = 0 ;
45670 PyObject * obj3 = 0 ;
45671 PyObject * obj4 = 0 ;
45672 PyObject * obj5 = 0 ;
45673 char * kwnames[] = {
45674 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45675 };
45676
45677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45678 if (obj0) {
45679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45680 if (!SWIG_IsOK(res1)) {
45681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45682 }
45683 arg1 = reinterpret_cast< wxMenu * >(argp1);
45684 }
45685 if (obj1) {
45686 ecode2 = SWIG_AsVal_int(obj1, &val2);
45687 if (!SWIG_IsOK(ecode2)) {
45688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45689 }
45690 arg2 = static_cast< int >(val2);
45691 }
45692 if (obj2) {
45693 {
45694 arg3 = wxString_in_helper(obj2);
45695 if (arg3 == NULL) SWIG_fail;
45696 temp3 = true;
45697 }
45698 }
45699 if (obj3) {
45700 {
45701 arg4 = wxString_in_helper(obj3);
45702 if (arg4 == NULL) SWIG_fail;
45703 temp4 = true;
45704 }
45705 }
45706 if (obj4) {
45707 ecode5 = SWIG_AsVal_int(obj4, &val5);
45708 if (!SWIG_IsOK(ecode5)) {
45709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45710 }
45711 arg5 = static_cast< wxItemKind >(val5);
45712 }
45713 if (obj5) {
45714 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45715 if (!SWIG_IsOK(res6)) {
45716 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45717 }
45718 arg6 = reinterpret_cast< wxMenu * >(argp6);
45719 }
45720 {
45721 PyThreadState* __tstate = wxPyBeginAllowThreads();
45722 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45723 wxPyEndAllowThreads(__tstate);
45724 if (PyErr_Occurred()) SWIG_fail;
45725 }
45726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45727 {
45728 if (temp3)
45729 delete arg3;
45730 }
45731 {
45732 if (temp4)
45733 delete arg4;
45734 }
45735 return resultobj;
45736 fail:
45737 {
45738 if (temp3)
45739 delete arg3;
45740 }
45741 {
45742 if (temp4)
45743 delete arg4;
45744 }
45745 return NULL;
45746 }
45747
45748
45749 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45750 PyObject *resultobj = 0;
45751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45752 void *argp1 = 0 ;
45753 int res1 = 0 ;
45754 PyObject *swig_obj[1] ;
45755
45756 if (!args) SWIG_fail;
45757 swig_obj[0] = args;
45758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45759 if (!SWIG_IsOK(res1)) {
45760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45761 }
45762 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45763 {
45764 PyThreadState* __tstate = wxPyBeginAllowThreads();
45765 delete arg1;
45766
45767 wxPyEndAllowThreads(__tstate);
45768 if (PyErr_Occurred()) SWIG_fail;
45769 }
45770 resultobj = SWIG_Py_Void();
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45778 PyObject *resultobj = 0;
45779 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45780 wxMenu *result = 0 ;
45781 void *argp1 = 0 ;
45782 int res1 = 0 ;
45783 PyObject *swig_obj[1] ;
45784
45785 if (!args) SWIG_fail;
45786 swig_obj[0] = args;
45787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45788 if (!SWIG_IsOK(res1)) {
45789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45790 }
45791 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45792 {
45793 PyThreadState* __tstate = wxPyBeginAllowThreads();
45794 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45795 wxPyEndAllowThreads(__tstate);
45796 if (PyErr_Occurred()) SWIG_fail;
45797 }
45798 {
45799 resultobj = wxPyMake_wxObject(result, 0);
45800 }
45801 return resultobj;
45802 fail:
45803 return NULL;
45804 }
45805
45806
45807 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45808 PyObject *resultobj = 0;
45809 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45810 wxMenu *arg2 = (wxMenu *) 0 ;
45811 void *argp1 = 0 ;
45812 int res1 = 0 ;
45813 void *argp2 = 0 ;
45814 int res2 = 0 ;
45815 PyObject * obj0 = 0 ;
45816 PyObject * obj1 = 0 ;
45817 char * kwnames[] = {
45818 (char *) "self",(char *) "menu", NULL
45819 };
45820
45821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45823 if (!SWIG_IsOK(res1)) {
45824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45825 }
45826 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45828 if (!SWIG_IsOK(res2)) {
45829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45830 }
45831 arg2 = reinterpret_cast< wxMenu * >(argp2);
45832 {
45833 PyThreadState* __tstate = wxPyBeginAllowThreads();
45834 (arg1)->SetMenu(arg2);
45835 wxPyEndAllowThreads(__tstate);
45836 if (PyErr_Occurred()) SWIG_fail;
45837 }
45838 resultobj = SWIG_Py_Void();
45839 return resultobj;
45840 fail:
45841 return NULL;
45842 }
45843
45844
45845 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45846 PyObject *resultobj = 0;
45847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45848 int arg2 ;
45849 void *argp1 = 0 ;
45850 int res1 = 0 ;
45851 int val2 ;
45852 int ecode2 = 0 ;
45853 PyObject * obj0 = 0 ;
45854 PyObject * obj1 = 0 ;
45855 char * kwnames[] = {
45856 (char *) "self",(char *) "id", NULL
45857 };
45858
45859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45861 if (!SWIG_IsOK(res1)) {
45862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45863 }
45864 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45865 ecode2 = SWIG_AsVal_int(obj1, &val2);
45866 if (!SWIG_IsOK(ecode2)) {
45867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45868 }
45869 arg2 = static_cast< int >(val2);
45870 {
45871 PyThreadState* __tstate = wxPyBeginAllowThreads();
45872 (arg1)->SetId(arg2);
45873 wxPyEndAllowThreads(__tstate);
45874 if (PyErr_Occurred()) SWIG_fail;
45875 }
45876 resultobj = SWIG_Py_Void();
45877 return resultobj;
45878 fail:
45879 return NULL;
45880 }
45881
45882
45883 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45884 PyObject *resultobj = 0;
45885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45886 int result;
45887 void *argp1 = 0 ;
45888 int res1 = 0 ;
45889 PyObject *swig_obj[1] ;
45890
45891 if (!args) SWIG_fail;
45892 swig_obj[0] = args;
45893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45894 if (!SWIG_IsOK(res1)) {
45895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45896 }
45897 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45898 {
45899 PyThreadState* __tstate = wxPyBeginAllowThreads();
45900 result = (int)((wxMenuItem const *)arg1)->GetId();
45901 wxPyEndAllowThreads(__tstate);
45902 if (PyErr_Occurred()) SWIG_fail;
45903 }
45904 resultobj = SWIG_From_int(static_cast< int >(result));
45905 return resultobj;
45906 fail:
45907 return NULL;
45908 }
45909
45910
45911 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45912 PyObject *resultobj = 0;
45913 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45914 bool result;
45915 void *argp1 = 0 ;
45916 int res1 = 0 ;
45917 PyObject *swig_obj[1] ;
45918
45919 if (!args) SWIG_fail;
45920 swig_obj[0] = args;
45921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45922 if (!SWIG_IsOK(res1)) {
45923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45924 }
45925 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45926 {
45927 PyThreadState* __tstate = wxPyBeginAllowThreads();
45928 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45929 wxPyEndAllowThreads(__tstate);
45930 if (PyErr_Occurred()) SWIG_fail;
45931 }
45932 {
45933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45934 }
45935 return resultobj;
45936 fail:
45937 return NULL;
45938 }
45939
45940
45941 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45942 PyObject *resultobj = 0;
45943 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45944 wxString *arg2 = 0 ;
45945 void *argp1 = 0 ;
45946 int res1 = 0 ;
45947 bool temp2 = false ;
45948 PyObject * obj0 = 0 ;
45949 PyObject * obj1 = 0 ;
45950 char * kwnames[] = {
45951 (char *) "self",(char *) "str", NULL
45952 };
45953
45954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45956 if (!SWIG_IsOK(res1)) {
45957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45958 }
45959 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45960 {
45961 arg2 = wxString_in_helper(obj1);
45962 if (arg2 == NULL) SWIG_fail;
45963 temp2 = true;
45964 }
45965 {
45966 PyThreadState* __tstate = wxPyBeginAllowThreads();
45967 (arg1)->SetText((wxString const &)*arg2);
45968 wxPyEndAllowThreads(__tstate);
45969 if (PyErr_Occurred()) SWIG_fail;
45970 }
45971 resultobj = SWIG_Py_Void();
45972 {
45973 if (temp2)
45974 delete arg2;
45975 }
45976 return resultobj;
45977 fail:
45978 {
45979 if (temp2)
45980 delete arg2;
45981 }
45982 return NULL;
45983 }
45984
45985
45986 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45987 PyObject *resultobj = 0;
45988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45989 wxString result;
45990 void *argp1 = 0 ;
45991 int res1 = 0 ;
45992 PyObject *swig_obj[1] ;
45993
45994 if (!args) SWIG_fail;
45995 swig_obj[0] = args;
45996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45997 if (!SWIG_IsOK(res1)) {
45998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45999 }
46000 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46001 {
46002 PyThreadState* __tstate = wxPyBeginAllowThreads();
46003 result = ((wxMenuItem const *)arg1)->GetLabel();
46004 wxPyEndAllowThreads(__tstate);
46005 if (PyErr_Occurred()) SWIG_fail;
46006 }
46007 {
46008 #if wxUSE_UNICODE
46009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46010 #else
46011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46012 #endif
46013 }
46014 return resultobj;
46015 fail:
46016 return NULL;
46017 }
46018
46019
46020 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46021 PyObject *resultobj = 0;
46022 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46023 wxString *result = 0 ;
46024 void *argp1 = 0 ;
46025 int res1 = 0 ;
46026 PyObject *swig_obj[1] ;
46027
46028 if (!args) SWIG_fail;
46029 swig_obj[0] = args;
46030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46031 if (!SWIG_IsOK(res1)) {
46032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46033 }
46034 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 {
46038 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46039 result = (wxString *) &_result_ref;
46040 }
46041 wxPyEndAllowThreads(__tstate);
46042 if (PyErr_Occurred()) SWIG_fail;
46043 }
46044 {
46045 #if wxUSE_UNICODE
46046 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46047 #else
46048 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46049 #endif
46050 }
46051 return resultobj;
46052 fail:
46053 return NULL;
46054 }
46055
46056
46057 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46058 PyObject *resultobj = 0;
46059 wxString *arg1 = 0 ;
46060 wxString result;
46061 bool temp1 = false ;
46062 PyObject * obj0 = 0 ;
46063 char * kwnames[] = {
46064 (char *) "text", NULL
46065 };
46066
46067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46068 {
46069 arg1 = wxString_in_helper(obj0);
46070 if (arg1 == NULL) SWIG_fail;
46071 temp1 = true;
46072 }
46073 {
46074 PyThreadState* __tstate = wxPyBeginAllowThreads();
46075 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46076 wxPyEndAllowThreads(__tstate);
46077 if (PyErr_Occurred()) SWIG_fail;
46078 }
46079 {
46080 #if wxUSE_UNICODE
46081 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46082 #else
46083 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46084 #endif
46085 }
46086 {
46087 if (temp1)
46088 delete arg1;
46089 }
46090 return resultobj;
46091 fail:
46092 {
46093 if (temp1)
46094 delete arg1;
46095 }
46096 return NULL;
46097 }
46098
46099
46100 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46101 PyObject *resultobj = 0;
46102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46103 wxItemKind result;
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_wxMenuItem, 0 | 0 );
46111 if (!SWIG_IsOK(res1)) {
46112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46113 }
46114 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46115 {
46116 PyThreadState* __tstate = wxPyBeginAllowThreads();
46117 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46118 wxPyEndAllowThreads(__tstate);
46119 if (PyErr_Occurred()) SWIG_fail;
46120 }
46121 resultobj = SWIG_From_int(static_cast< int >(result));
46122 return resultobj;
46123 fail:
46124 return NULL;
46125 }
46126
46127
46128 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46129 PyObject *resultobj = 0;
46130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46131 wxItemKind arg2 ;
46132 void *argp1 = 0 ;
46133 int res1 = 0 ;
46134 int val2 ;
46135 int ecode2 = 0 ;
46136 PyObject * obj0 = 0 ;
46137 PyObject * obj1 = 0 ;
46138 char * kwnames[] = {
46139 (char *) "self",(char *) "kind", NULL
46140 };
46141
46142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46144 if (!SWIG_IsOK(res1)) {
46145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46146 }
46147 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46148 ecode2 = SWIG_AsVal_int(obj1, &val2);
46149 if (!SWIG_IsOK(ecode2)) {
46150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46151 }
46152 arg2 = static_cast< wxItemKind >(val2);
46153 {
46154 PyThreadState* __tstate = wxPyBeginAllowThreads();
46155 (arg1)->SetKind(arg2);
46156 wxPyEndAllowThreads(__tstate);
46157 if (PyErr_Occurred()) SWIG_fail;
46158 }
46159 resultobj = SWIG_Py_Void();
46160 return resultobj;
46161 fail:
46162 return NULL;
46163 }
46164
46165
46166 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46167 PyObject *resultobj = 0;
46168 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46169 bool arg2 ;
46170 void *argp1 = 0 ;
46171 int res1 = 0 ;
46172 bool val2 ;
46173 int ecode2 = 0 ;
46174 PyObject * obj0 = 0 ;
46175 PyObject * obj1 = 0 ;
46176 char * kwnames[] = {
46177 (char *) "self",(char *) "checkable", NULL
46178 };
46179
46180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46182 if (!SWIG_IsOK(res1)) {
46183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46184 }
46185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46186 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46187 if (!SWIG_IsOK(ecode2)) {
46188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46189 }
46190 arg2 = static_cast< bool >(val2);
46191 {
46192 PyThreadState* __tstate = wxPyBeginAllowThreads();
46193 (arg1)->SetCheckable(arg2);
46194 wxPyEndAllowThreads(__tstate);
46195 if (PyErr_Occurred()) SWIG_fail;
46196 }
46197 resultobj = SWIG_Py_Void();
46198 return resultobj;
46199 fail:
46200 return NULL;
46201 }
46202
46203
46204 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46205 PyObject *resultobj = 0;
46206 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46207 bool result;
46208 void *argp1 = 0 ;
46209 int res1 = 0 ;
46210 PyObject *swig_obj[1] ;
46211
46212 if (!args) SWIG_fail;
46213 swig_obj[0] = args;
46214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46215 if (!SWIG_IsOK(res1)) {
46216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46217 }
46218 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46219 {
46220 PyThreadState* __tstate = wxPyBeginAllowThreads();
46221 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46222 wxPyEndAllowThreads(__tstate);
46223 if (PyErr_Occurred()) SWIG_fail;
46224 }
46225 {
46226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46227 }
46228 return resultobj;
46229 fail:
46230 return NULL;
46231 }
46232
46233
46234 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46235 PyObject *resultobj = 0;
46236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46237 bool result;
46238 void *argp1 = 0 ;
46239 int res1 = 0 ;
46240 PyObject *swig_obj[1] ;
46241
46242 if (!args) SWIG_fail;
46243 swig_obj[0] = args;
46244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46245 if (!SWIG_IsOK(res1)) {
46246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46247 }
46248 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46249 {
46250 PyThreadState* __tstate = wxPyBeginAllowThreads();
46251 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46252 wxPyEndAllowThreads(__tstate);
46253 if (PyErr_Occurred()) SWIG_fail;
46254 }
46255 {
46256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46257 }
46258 return resultobj;
46259 fail:
46260 return NULL;
46261 }
46262
46263
46264 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46265 PyObject *resultobj = 0;
46266 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46267 wxMenu *arg2 = (wxMenu *) 0 ;
46268 void *argp1 = 0 ;
46269 int res1 = 0 ;
46270 void *argp2 = 0 ;
46271 int res2 = 0 ;
46272 PyObject * obj0 = 0 ;
46273 PyObject * obj1 = 0 ;
46274 char * kwnames[] = {
46275 (char *) "self",(char *) "menu", NULL
46276 };
46277
46278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46280 if (!SWIG_IsOK(res1)) {
46281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46282 }
46283 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46285 if (!SWIG_IsOK(res2)) {
46286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46287 }
46288 arg2 = reinterpret_cast< wxMenu * >(argp2);
46289 {
46290 PyThreadState* __tstate = wxPyBeginAllowThreads();
46291 (arg1)->SetSubMenu(arg2);
46292 wxPyEndAllowThreads(__tstate);
46293 if (PyErr_Occurred()) SWIG_fail;
46294 }
46295 resultobj = SWIG_Py_Void();
46296 return resultobj;
46297 fail:
46298 return NULL;
46299 }
46300
46301
46302 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46303 PyObject *resultobj = 0;
46304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46305 wxMenu *result = 0 ;
46306 void *argp1 = 0 ;
46307 int res1 = 0 ;
46308 PyObject *swig_obj[1] ;
46309
46310 if (!args) SWIG_fail;
46311 swig_obj[0] = args;
46312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46313 if (!SWIG_IsOK(res1)) {
46314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46315 }
46316 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46317 {
46318 PyThreadState* __tstate = wxPyBeginAllowThreads();
46319 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46320 wxPyEndAllowThreads(__tstate);
46321 if (PyErr_Occurred()) SWIG_fail;
46322 }
46323 {
46324 resultobj = wxPyMake_wxObject(result, 0);
46325 }
46326 return resultobj;
46327 fail:
46328 return NULL;
46329 }
46330
46331
46332 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46333 PyObject *resultobj = 0;
46334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46335 bool arg2 = (bool) true ;
46336 void *argp1 = 0 ;
46337 int res1 = 0 ;
46338 bool val2 ;
46339 int ecode2 = 0 ;
46340 PyObject * obj0 = 0 ;
46341 PyObject * obj1 = 0 ;
46342 char * kwnames[] = {
46343 (char *) "self",(char *) "enable", NULL
46344 };
46345
46346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46348 if (!SWIG_IsOK(res1)) {
46349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46350 }
46351 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46352 if (obj1) {
46353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46354 if (!SWIG_IsOK(ecode2)) {
46355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46356 }
46357 arg2 = static_cast< bool >(val2);
46358 }
46359 {
46360 PyThreadState* __tstate = wxPyBeginAllowThreads();
46361 (arg1)->Enable(arg2);
46362 wxPyEndAllowThreads(__tstate);
46363 if (PyErr_Occurred()) SWIG_fail;
46364 }
46365 resultobj = SWIG_Py_Void();
46366 return resultobj;
46367 fail:
46368 return NULL;
46369 }
46370
46371
46372 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46373 PyObject *resultobj = 0;
46374 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46375 bool result;
46376 void *argp1 = 0 ;
46377 int res1 = 0 ;
46378 PyObject *swig_obj[1] ;
46379
46380 if (!args) SWIG_fail;
46381 swig_obj[0] = args;
46382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46383 if (!SWIG_IsOK(res1)) {
46384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46385 }
46386 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46387 {
46388 PyThreadState* __tstate = wxPyBeginAllowThreads();
46389 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46390 wxPyEndAllowThreads(__tstate);
46391 if (PyErr_Occurred()) SWIG_fail;
46392 }
46393 {
46394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46395 }
46396 return resultobj;
46397 fail:
46398 return NULL;
46399 }
46400
46401
46402 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46403 PyObject *resultobj = 0;
46404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46405 bool arg2 = (bool) true ;
46406 void *argp1 = 0 ;
46407 int res1 = 0 ;
46408 bool val2 ;
46409 int ecode2 = 0 ;
46410 PyObject * obj0 = 0 ;
46411 PyObject * obj1 = 0 ;
46412 char * kwnames[] = {
46413 (char *) "self",(char *) "check", NULL
46414 };
46415
46416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46418 if (!SWIG_IsOK(res1)) {
46419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46420 }
46421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46422 if (obj1) {
46423 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46424 if (!SWIG_IsOK(ecode2)) {
46425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46426 }
46427 arg2 = static_cast< bool >(val2);
46428 }
46429 {
46430 PyThreadState* __tstate = wxPyBeginAllowThreads();
46431 (arg1)->Check(arg2);
46432 wxPyEndAllowThreads(__tstate);
46433 if (PyErr_Occurred()) SWIG_fail;
46434 }
46435 resultobj = SWIG_Py_Void();
46436 return resultobj;
46437 fail:
46438 return NULL;
46439 }
46440
46441
46442 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46443 PyObject *resultobj = 0;
46444 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46445 bool result;
46446 void *argp1 = 0 ;
46447 int res1 = 0 ;
46448 PyObject *swig_obj[1] ;
46449
46450 if (!args) SWIG_fail;
46451 swig_obj[0] = args;
46452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46453 if (!SWIG_IsOK(res1)) {
46454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46455 }
46456 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46457 {
46458 PyThreadState* __tstate = wxPyBeginAllowThreads();
46459 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46460 wxPyEndAllowThreads(__tstate);
46461 if (PyErr_Occurred()) SWIG_fail;
46462 }
46463 {
46464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46465 }
46466 return resultobj;
46467 fail:
46468 return NULL;
46469 }
46470
46471
46472 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46473 PyObject *resultobj = 0;
46474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46475 void *argp1 = 0 ;
46476 int res1 = 0 ;
46477 PyObject *swig_obj[1] ;
46478
46479 if (!args) SWIG_fail;
46480 swig_obj[0] = args;
46481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46482 if (!SWIG_IsOK(res1)) {
46483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46484 }
46485 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46486 {
46487 PyThreadState* __tstate = wxPyBeginAllowThreads();
46488 (arg1)->Toggle();
46489 wxPyEndAllowThreads(__tstate);
46490 if (PyErr_Occurred()) SWIG_fail;
46491 }
46492 resultobj = SWIG_Py_Void();
46493 return resultobj;
46494 fail:
46495 return NULL;
46496 }
46497
46498
46499 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46500 PyObject *resultobj = 0;
46501 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46502 wxString *arg2 = 0 ;
46503 void *argp1 = 0 ;
46504 int res1 = 0 ;
46505 bool temp2 = false ;
46506 PyObject * obj0 = 0 ;
46507 PyObject * obj1 = 0 ;
46508 char * kwnames[] = {
46509 (char *) "self",(char *) "str", NULL
46510 };
46511
46512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46514 if (!SWIG_IsOK(res1)) {
46515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46516 }
46517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46518 {
46519 arg2 = wxString_in_helper(obj1);
46520 if (arg2 == NULL) SWIG_fail;
46521 temp2 = true;
46522 }
46523 {
46524 PyThreadState* __tstate = wxPyBeginAllowThreads();
46525 (arg1)->SetHelp((wxString const &)*arg2);
46526 wxPyEndAllowThreads(__tstate);
46527 if (PyErr_Occurred()) SWIG_fail;
46528 }
46529 resultobj = SWIG_Py_Void();
46530 {
46531 if (temp2)
46532 delete arg2;
46533 }
46534 return resultobj;
46535 fail:
46536 {
46537 if (temp2)
46538 delete arg2;
46539 }
46540 return NULL;
46541 }
46542
46543
46544 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46545 PyObject *resultobj = 0;
46546 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46547 wxString *result = 0 ;
46548 void *argp1 = 0 ;
46549 int res1 = 0 ;
46550 PyObject *swig_obj[1] ;
46551
46552 if (!args) SWIG_fail;
46553 swig_obj[0] = args;
46554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46555 if (!SWIG_IsOK(res1)) {
46556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46557 }
46558 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46559 {
46560 PyThreadState* __tstate = wxPyBeginAllowThreads();
46561 {
46562 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46563 result = (wxString *) &_result_ref;
46564 }
46565 wxPyEndAllowThreads(__tstate);
46566 if (PyErr_Occurred()) SWIG_fail;
46567 }
46568 {
46569 #if wxUSE_UNICODE
46570 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46571 #else
46572 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46573 #endif
46574 }
46575 return resultobj;
46576 fail:
46577 return NULL;
46578 }
46579
46580
46581 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46582 PyObject *resultobj = 0;
46583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46584 wxAcceleratorEntry *result = 0 ;
46585 void *argp1 = 0 ;
46586 int res1 = 0 ;
46587 PyObject *swig_obj[1] ;
46588
46589 if (!args) SWIG_fail;
46590 swig_obj[0] = args;
46591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46592 if (!SWIG_IsOK(res1)) {
46593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46594 }
46595 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46596 {
46597 PyThreadState* __tstate = wxPyBeginAllowThreads();
46598 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46599 wxPyEndAllowThreads(__tstate);
46600 if (PyErr_Occurred()) SWIG_fail;
46601 }
46602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46603 return resultobj;
46604 fail:
46605 return NULL;
46606 }
46607
46608
46609 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46610 PyObject *resultobj = 0;
46611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46612 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46613 void *argp1 = 0 ;
46614 int res1 = 0 ;
46615 void *argp2 = 0 ;
46616 int res2 = 0 ;
46617 PyObject * obj0 = 0 ;
46618 PyObject * obj1 = 0 ;
46619 char * kwnames[] = {
46620 (char *) "self",(char *) "accel", NULL
46621 };
46622
46623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46625 if (!SWIG_IsOK(res1)) {
46626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46627 }
46628 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46630 if (!SWIG_IsOK(res2)) {
46631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46632 }
46633 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46634 {
46635 PyThreadState* __tstate = wxPyBeginAllowThreads();
46636 (arg1)->SetAccel(arg2);
46637 wxPyEndAllowThreads(__tstate);
46638 if (PyErr_Occurred()) SWIG_fail;
46639 }
46640 resultobj = SWIG_Py_Void();
46641 return resultobj;
46642 fail:
46643 return NULL;
46644 }
46645
46646
46647 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46648 PyObject *resultobj = 0;
46649 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46650 wxBitmap *arg2 = 0 ;
46651 void *argp1 = 0 ;
46652 int res1 = 0 ;
46653 void *argp2 = 0 ;
46654 int res2 = 0 ;
46655 PyObject * obj0 = 0 ;
46656 PyObject * obj1 = 0 ;
46657 char * kwnames[] = {
46658 (char *) "self",(char *) "bitmap", NULL
46659 };
46660
46661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46663 if (!SWIG_IsOK(res1)) {
46664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46665 }
46666 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46667 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46668 if (!SWIG_IsOK(res2)) {
46669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46670 }
46671 if (!argp2) {
46672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46673 }
46674 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46675 {
46676 PyThreadState* __tstate = wxPyBeginAllowThreads();
46677 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46678 wxPyEndAllowThreads(__tstate);
46679 if (PyErr_Occurred()) SWIG_fail;
46680 }
46681 resultobj = SWIG_Py_Void();
46682 return resultobj;
46683 fail:
46684 return NULL;
46685 }
46686
46687
46688 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46689 PyObject *resultobj = 0;
46690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46691 wxBitmap *result = 0 ;
46692 void *argp1 = 0 ;
46693 int res1 = 0 ;
46694 PyObject *swig_obj[1] ;
46695
46696 if (!args) SWIG_fail;
46697 swig_obj[0] = args;
46698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46699 if (!SWIG_IsOK(res1)) {
46700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46701 }
46702 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46703 {
46704 PyThreadState* __tstate = wxPyBeginAllowThreads();
46705 {
46706 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46707 result = (wxBitmap *) &_result_ref;
46708 }
46709 wxPyEndAllowThreads(__tstate);
46710 if (PyErr_Occurred()) SWIG_fail;
46711 }
46712 {
46713 wxBitmap* resultptr = new wxBitmap(*result);
46714 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46715 }
46716 return resultobj;
46717 fail:
46718 return NULL;
46719 }
46720
46721
46722 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46723 PyObject *resultobj = 0;
46724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46725 wxFont *arg2 = 0 ;
46726 void *argp1 = 0 ;
46727 int res1 = 0 ;
46728 void *argp2 = 0 ;
46729 int res2 = 0 ;
46730 PyObject * obj0 = 0 ;
46731 PyObject * obj1 = 0 ;
46732 char * kwnames[] = {
46733 (char *) "self",(char *) "font", NULL
46734 };
46735
46736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46738 if (!SWIG_IsOK(res1)) {
46739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46740 }
46741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46743 if (!SWIG_IsOK(res2)) {
46744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46745 }
46746 if (!argp2) {
46747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46748 }
46749 arg2 = reinterpret_cast< wxFont * >(argp2);
46750 {
46751 PyThreadState* __tstate = wxPyBeginAllowThreads();
46752 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46753 wxPyEndAllowThreads(__tstate);
46754 if (PyErr_Occurred()) SWIG_fail;
46755 }
46756 resultobj = SWIG_Py_Void();
46757 return resultobj;
46758 fail:
46759 return NULL;
46760 }
46761
46762
46763 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46764 PyObject *resultobj = 0;
46765 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46766 wxFont result;
46767 void *argp1 = 0 ;
46768 int res1 = 0 ;
46769 PyObject *swig_obj[1] ;
46770
46771 if (!args) SWIG_fail;
46772 swig_obj[0] = args;
46773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46774 if (!SWIG_IsOK(res1)) {
46775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46776 }
46777 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46778 {
46779 PyThreadState* __tstate = wxPyBeginAllowThreads();
46780 result = wxMenuItem_GetFont(arg1);
46781 wxPyEndAllowThreads(__tstate);
46782 if (PyErr_Occurred()) SWIG_fail;
46783 }
46784 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46785 return resultobj;
46786 fail:
46787 return NULL;
46788 }
46789
46790
46791 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46792 PyObject *resultobj = 0;
46793 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46794 wxColour *arg2 = 0 ;
46795 void *argp1 = 0 ;
46796 int res1 = 0 ;
46797 wxColour temp2 ;
46798 PyObject * obj0 = 0 ;
46799 PyObject * obj1 = 0 ;
46800 char * kwnames[] = {
46801 (char *) "self",(char *) "colText", NULL
46802 };
46803
46804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46806 if (!SWIG_IsOK(res1)) {
46807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46808 }
46809 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46810 {
46811 arg2 = &temp2;
46812 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46813 }
46814 {
46815 PyThreadState* __tstate = wxPyBeginAllowThreads();
46816 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46817 wxPyEndAllowThreads(__tstate);
46818 if (PyErr_Occurred()) SWIG_fail;
46819 }
46820 resultobj = SWIG_Py_Void();
46821 return resultobj;
46822 fail:
46823 return NULL;
46824 }
46825
46826
46827 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46828 PyObject *resultobj = 0;
46829 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46830 wxColour result;
46831 void *argp1 = 0 ;
46832 int res1 = 0 ;
46833 PyObject *swig_obj[1] ;
46834
46835 if (!args) SWIG_fail;
46836 swig_obj[0] = args;
46837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46838 if (!SWIG_IsOK(res1)) {
46839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46840 }
46841 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46842 {
46843 PyThreadState* __tstate = wxPyBeginAllowThreads();
46844 result = wxMenuItem_GetTextColour(arg1);
46845 wxPyEndAllowThreads(__tstate);
46846 if (PyErr_Occurred()) SWIG_fail;
46847 }
46848 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46849 return resultobj;
46850 fail:
46851 return NULL;
46852 }
46853
46854
46855 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46856 PyObject *resultobj = 0;
46857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46858 wxColour *arg2 = 0 ;
46859 void *argp1 = 0 ;
46860 int res1 = 0 ;
46861 wxColour temp2 ;
46862 PyObject * obj0 = 0 ;
46863 PyObject * obj1 = 0 ;
46864 char * kwnames[] = {
46865 (char *) "self",(char *) "colBack", NULL
46866 };
46867
46868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46870 if (!SWIG_IsOK(res1)) {
46871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46872 }
46873 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46874 {
46875 arg2 = &temp2;
46876 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46877 }
46878 {
46879 PyThreadState* __tstate = wxPyBeginAllowThreads();
46880 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46881 wxPyEndAllowThreads(__tstate);
46882 if (PyErr_Occurred()) SWIG_fail;
46883 }
46884 resultobj = SWIG_Py_Void();
46885 return resultobj;
46886 fail:
46887 return NULL;
46888 }
46889
46890
46891 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46892 PyObject *resultobj = 0;
46893 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46894 wxColour result;
46895 void *argp1 = 0 ;
46896 int res1 = 0 ;
46897 PyObject *swig_obj[1] ;
46898
46899 if (!args) SWIG_fail;
46900 swig_obj[0] = args;
46901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46902 if (!SWIG_IsOK(res1)) {
46903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46904 }
46905 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46906 {
46907 PyThreadState* __tstate = wxPyBeginAllowThreads();
46908 result = wxMenuItem_GetBackgroundColour(arg1);
46909 wxPyEndAllowThreads(__tstate);
46910 if (PyErr_Occurred()) SWIG_fail;
46911 }
46912 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46913 return resultobj;
46914 fail:
46915 return NULL;
46916 }
46917
46918
46919 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46920 PyObject *resultobj = 0;
46921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46922 wxBitmap *arg2 = 0 ;
46923 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46924 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46925 void *argp1 = 0 ;
46926 int res1 = 0 ;
46927 void *argp2 = 0 ;
46928 int res2 = 0 ;
46929 void *argp3 = 0 ;
46930 int res3 = 0 ;
46931 PyObject * obj0 = 0 ;
46932 PyObject * obj1 = 0 ;
46933 PyObject * obj2 = 0 ;
46934 char * kwnames[] = {
46935 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46936 };
46937
46938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46940 if (!SWIG_IsOK(res1)) {
46941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46942 }
46943 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46945 if (!SWIG_IsOK(res2)) {
46946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46947 }
46948 if (!argp2) {
46949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46950 }
46951 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46952 if (obj2) {
46953 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46954 if (!SWIG_IsOK(res3)) {
46955 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46956 }
46957 if (!argp3) {
46958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46959 }
46960 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46961 }
46962 {
46963 PyThreadState* __tstate = wxPyBeginAllowThreads();
46964 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46965 wxPyEndAllowThreads(__tstate);
46966 if (PyErr_Occurred()) SWIG_fail;
46967 }
46968 resultobj = SWIG_Py_Void();
46969 return resultobj;
46970 fail:
46971 return NULL;
46972 }
46973
46974
46975 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46976 PyObject *resultobj = 0;
46977 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46978 wxBitmap *arg2 = 0 ;
46979 void *argp1 = 0 ;
46980 int res1 = 0 ;
46981 void *argp2 = 0 ;
46982 int res2 = 0 ;
46983 PyObject * obj0 = 0 ;
46984 PyObject * obj1 = 0 ;
46985 char * kwnames[] = {
46986 (char *) "self",(char *) "bmpDisabled", NULL
46987 };
46988
46989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46991 if (!SWIG_IsOK(res1)) {
46992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46993 }
46994 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46995 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46996 if (!SWIG_IsOK(res2)) {
46997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46998 }
46999 if (!argp2) {
47000 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47001 }
47002 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47003 {
47004 PyThreadState* __tstate = wxPyBeginAllowThreads();
47005 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47006 wxPyEndAllowThreads(__tstate);
47007 if (PyErr_Occurred()) SWIG_fail;
47008 }
47009 resultobj = SWIG_Py_Void();
47010 return resultobj;
47011 fail:
47012 return NULL;
47013 }
47014
47015
47016 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47017 PyObject *resultobj = 0;
47018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47019 wxBitmap *result = 0 ;
47020 void *argp1 = 0 ;
47021 int res1 = 0 ;
47022 PyObject *swig_obj[1] ;
47023
47024 if (!args) SWIG_fail;
47025 swig_obj[0] = args;
47026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47027 if (!SWIG_IsOK(res1)) {
47028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47029 }
47030 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47031 {
47032 PyThreadState* __tstate = wxPyBeginAllowThreads();
47033 {
47034 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47035 result = (wxBitmap *) &_result_ref;
47036 }
47037 wxPyEndAllowThreads(__tstate);
47038 if (PyErr_Occurred()) SWIG_fail;
47039 }
47040 {
47041 wxBitmap* resultptr = new wxBitmap(*result);
47042 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47043 }
47044 return resultobj;
47045 fail:
47046 return NULL;
47047 }
47048
47049
47050 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47051 PyObject *resultobj = 0;
47052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47053 int arg2 ;
47054 void *argp1 = 0 ;
47055 int res1 = 0 ;
47056 int val2 ;
47057 int ecode2 = 0 ;
47058 PyObject * obj0 = 0 ;
47059 PyObject * obj1 = 0 ;
47060 char * kwnames[] = {
47061 (char *) "self",(char *) "nWidth", NULL
47062 };
47063
47064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47066 if (!SWIG_IsOK(res1)) {
47067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47068 }
47069 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47070 ecode2 = SWIG_AsVal_int(obj1, &val2);
47071 if (!SWIG_IsOK(ecode2)) {
47072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47073 }
47074 arg2 = static_cast< int >(val2);
47075 {
47076 PyThreadState* __tstate = wxPyBeginAllowThreads();
47077 wxMenuItem_SetMarginWidth(arg1,arg2);
47078 wxPyEndAllowThreads(__tstate);
47079 if (PyErr_Occurred()) SWIG_fail;
47080 }
47081 resultobj = SWIG_Py_Void();
47082 return resultobj;
47083 fail:
47084 return NULL;
47085 }
47086
47087
47088 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47089 PyObject *resultobj = 0;
47090 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47091 int result;
47092 void *argp1 = 0 ;
47093 int res1 = 0 ;
47094 PyObject *swig_obj[1] ;
47095
47096 if (!args) SWIG_fail;
47097 swig_obj[0] = args;
47098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47099 if (!SWIG_IsOK(res1)) {
47100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47101 }
47102 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47103 {
47104 PyThreadState* __tstate = wxPyBeginAllowThreads();
47105 result = (int)wxMenuItem_GetMarginWidth(arg1);
47106 wxPyEndAllowThreads(__tstate);
47107 if (PyErr_Occurred()) SWIG_fail;
47108 }
47109 resultobj = SWIG_From_int(static_cast< int >(result));
47110 return resultobj;
47111 fail:
47112 return NULL;
47113 }
47114
47115
47116 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47117 PyObject *resultobj = 0;
47118 int result;
47119
47120 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47121 {
47122 PyThreadState* __tstate = wxPyBeginAllowThreads();
47123 result = (int)wxMenuItem_GetDefaultMarginWidth();
47124 wxPyEndAllowThreads(__tstate);
47125 if (PyErr_Occurred()) SWIG_fail;
47126 }
47127 resultobj = SWIG_From_int(static_cast< int >(result));
47128 return resultobj;
47129 fail:
47130 return NULL;
47131 }
47132
47133
47134 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47135 PyObject *resultobj = 0;
47136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47137 bool result;
47138 void *argp1 = 0 ;
47139 int res1 = 0 ;
47140 PyObject *swig_obj[1] ;
47141
47142 if (!args) SWIG_fail;
47143 swig_obj[0] = args;
47144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47145 if (!SWIG_IsOK(res1)) {
47146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47147 }
47148 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47149 {
47150 PyThreadState* __tstate = wxPyBeginAllowThreads();
47151 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47152 wxPyEndAllowThreads(__tstate);
47153 if (PyErr_Occurred()) SWIG_fail;
47154 }
47155 {
47156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47157 }
47158 return resultobj;
47159 fail:
47160 return NULL;
47161 }
47162
47163
47164 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47165 PyObject *resultobj = 0;
47166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47167 bool arg2 = (bool) true ;
47168 void *argp1 = 0 ;
47169 int res1 = 0 ;
47170 bool val2 ;
47171 int ecode2 = 0 ;
47172 PyObject * obj0 = 0 ;
47173 PyObject * obj1 = 0 ;
47174 char * kwnames[] = {
47175 (char *) "self",(char *) "ownerDrawn", NULL
47176 };
47177
47178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47180 if (!SWIG_IsOK(res1)) {
47181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47182 }
47183 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47184 if (obj1) {
47185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47186 if (!SWIG_IsOK(ecode2)) {
47187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47188 }
47189 arg2 = static_cast< bool >(val2);
47190 }
47191 {
47192 PyThreadState* __tstate = wxPyBeginAllowThreads();
47193 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47194 wxPyEndAllowThreads(__tstate);
47195 if (PyErr_Occurred()) SWIG_fail;
47196 }
47197 resultobj = SWIG_Py_Void();
47198 return resultobj;
47199 fail:
47200 return NULL;
47201 }
47202
47203
47204 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47205 PyObject *resultobj = 0;
47206 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47207 void *argp1 = 0 ;
47208 int res1 = 0 ;
47209 PyObject *swig_obj[1] ;
47210
47211 if (!args) SWIG_fail;
47212 swig_obj[0] = args;
47213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47214 if (!SWIG_IsOK(res1)) {
47215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47216 }
47217 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47218 {
47219 PyThreadState* __tstate = wxPyBeginAllowThreads();
47220 wxMenuItem_ResetOwnerDrawn(arg1);
47221 wxPyEndAllowThreads(__tstate);
47222 if (PyErr_Occurred()) SWIG_fail;
47223 }
47224 resultobj = SWIG_Py_Void();
47225 return resultobj;
47226 fail:
47227 return NULL;
47228 }
47229
47230
47231 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47232 PyObject *obj;
47233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47234 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47235 return SWIG_Py_Void();
47236 }
47237
47238 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47239 return SWIG_Python_InitShadowInstance(args);
47240 }
47241
47242 SWIGINTERN int ControlNameStr_set(PyObject *) {
47243 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47244 return 1;
47245 }
47246
47247
47248 SWIGINTERN PyObject *ControlNameStr_get(void) {
47249 PyObject *pyobj = 0;
47250
47251 {
47252 #if wxUSE_UNICODE
47253 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47254 #else
47255 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47256 #endif
47257 }
47258 return pyobj;
47259 }
47260
47261
47262 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47263 PyObject *resultobj = 0;
47264 wxWindow *arg1 = (wxWindow *) 0 ;
47265 int arg2 = (int) -1 ;
47266 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47267 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47268 wxSize const &arg4_defvalue = wxDefaultSize ;
47269 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47270 long arg5 = (long) 0 ;
47271 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47272 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47273 wxString const &arg7_defvalue = wxPyControlNameStr ;
47274 wxString *arg7 = (wxString *) &arg7_defvalue ;
47275 wxControl *result = 0 ;
47276 void *argp1 = 0 ;
47277 int res1 = 0 ;
47278 int val2 ;
47279 int ecode2 = 0 ;
47280 wxPoint temp3 ;
47281 wxSize temp4 ;
47282 long val5 ;
47283 int ecode5 = 0 ;
47284 void *argp6 = 0 ;
47285 int res6 = 0 ;
47286 bool temp7 = false ;
47287 PyObject * obj0 = 0 ;
47288 PyObject * obj1 = 0 ;
47289 PyObject * obj2 = 0 ;
47290 PyObject * obj3 = 0 ;
47291 PyObject * obj4 = 0 ;
47292 PyObject * obj5 = 0 ;
47293 PyObject * obj6 = 0 ;
47294 char * kwnames[] = {
47295 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47296 };
47297
47298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47300 if (!SWIG_IsOK(res1)) {
47301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47302 }
47303 arg1 = reinterpret_cast< wxWindow * >(argp1);
47304 if (obj1) {
47305 ecode2 = SWIG_AsVal_int(obj1, &val2);
47306 if (!SWIG_IsOK(ecode2)) {
47307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47308 }
47309 arg2 = static_cast< int >(val2);
47310 }
47311 if (obj2) {
47312 {
47313 arg3 = &temp3;
47314 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47315 }
47316 }
47317 if (obj3) {
47318 {
47319 arg4 = &temp4;
47320 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47321 }
47322 }
47323 if (obj4) {
47324 ecode5 = SWIG_AsVal_long(obj4, &val5);
47325 if (!SWIG_IsOK(ecode5)) {
47326 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47327 }
47328 arg5 = static_cast< long >(val5);
47329 }
47330 if (obj5) {
47331 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47332 if (!SWIG_IsOK(res6)) {
47333 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47334 }
47335 if (!argp6) {
47336 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47337 }
47338 arg6 = reinterpret_cast< wxValidator * >(argp6);
47339 }
47340 if (obj6) {
47341 {
47342 arg7 = wxString_in_helper(obj6);
47343 if (arg7 == NULL) SWIG_fail;
47344 temp7 = true;
47345 }
47346 }
47347 {
47348 if (!wxPyCheckForApp()) SWIG_fail;
47349 PyThreadState* __tstate = wxPyBeginAllowThreads();
47350 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47351 wxPyEndAllowThreads(__tstate);
47352 if (PyErr_Occurred()) SWIG_fail;
47353 }
47354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47355 {
47356 if (temp7)
47357 delete arg7;
47358 }
47359 return resultobj;
47360 fail:
47361 {
47362 if (temp7)
47363 delete arg7;
47364 }
47365 return NULL;
47366 }
47367
47368
47369 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47370 PyObject *resultobj = 0;
47371 wxControl *result = 0 ;
47372
47373 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47374 {
47375 if (!wxPyCheckForApp()) SWIG_fail;
47376 PyThreadState* __tstate = wxPyBeginAllowThreads();
47377 result = (wxControl *)new wxControl();
47378 wxPyEndAllowThreads(__tstate);
47379 if (PyErr_Occurred()) SWIG_fail;
47380 }
47381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47382 return resultobj;
47383 fail:
47384 return NULL;
47385 }
47386
47387
47388 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47389 PyObject *resultobj = 0;
47390 wxControl *arg1 = (wxControl *) 0 ;
47391 wxWindow *arg2 = (wxWindow *) 0 ;
47392 int arg3 = (int) -1 ;
47393 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47394 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47395 wxSize const &arg5_defvalue = wxDefaultSize ;
47396 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47397 long arg6 = (long) 0 ;
47398 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47399 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47400 wxString const &arg8_defvalue = wxPyControlNameStr ;
47401 wxString *arg8 = (wxString *) &arg8_defvalue ;
47402 bool result;
47403 void *argp1 = 0 ;
47404 int res1 = 0 ;
47405 void *argp2 = 0 ;
47406 int res2 = 0 ;
47407 int val3 ;
47408 int ecode3 = 0 ;
47409 wxPoint temp4 ;
47410 wxSize temp5 ;
47411 long val6 ;
47412 int ecode6 = 0 ;
47413 void *argp7 = 0 ;
47414 int res7 = 0 ;
47415 bool temp8 = false ;
47416 PyObject * obj0 = 0 ;
47417 PyObject * obj1 = 0 ;
47418 PyObject * obj2 = 0 ;
47419 PyObject * obj3 = 0 ;
47420 PyObject * obj4 = 0 ;
47421 PyObject * obj5 = 0 ;
47422 PyObject * obj6 = 0 ;
47423 PyObject * obj7 = 0 ;
47424 char * kwnames[] = {
47425 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47426 };
47427
47428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47430 if (!SWIG_IsOK(res1)) {
47431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47432 }
47433 arg1 = reinterpret_cast< wxControl * >(argp1);
47434 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47435 if (!SWIG_IsOK(res2)) {
47436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47437 }
47438 arg2 = reinterpret_cast< wxWindow * >(argp2);
47439 if (obj2) {
47440 ecode3 = SWIG_AsVal_int(obj2, &val3);
47441 if (!SWIG_IsOK(ecode3)) {
47442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47443 }
47444 arg3 = static_cast< int >(val3);
47445 }
47446 if (obj3) {
47447 {
47448 arg4 = &temp4;
47449 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47450 }
47451 }
47452 if (obj4) {
47453 {
47454 arg5 = &temp5;
47455 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47456 }
47457 }
47458 if (obj5) {
47459 ecode6 = SWIG_AsVal_long(obj5, &val6);
47460 if (!SWIG_IsOK(ecode6)) {
47461 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47462 }
47463 arg6 = static_cast< long >(val6);
47464 }
47465 if (obj6) {
47466 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47467 if (!SWIG_IsOK(res7)) {
47468 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47469 }
47470 if (!argp7) {
47471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47472 }
47473 arg7 = reinterpret_cast< wxValidator * >(argp7);
47474 }
47475 if (obj7) {
47476 {
47477 arg8 = wxString_in_helper(obj7);
47478 if (arg8 == NULL) SWIG_fail;
47479 temp8 = true;
47480 }
47481 }
47482 {
47483 PyThreadState* __tstate = wxPyBeginAllowThreads();
47484 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47485 wxPyEndAllowThreads(__tstate);
47486 if (PyErr_Occurred()) SWIG_fail;
47487 }
47488 {
47489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47490 }
47491 {
47492 if (temp8)
47493 delete arg8;
47494 }
47495 return resultobj;
47496 fail:
47497 {
47498 if (temp8)
47499 delete arg8;
47500 }
47501 return NULL;
47502 }
47503
47504
47505 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47506 PyObject *resultobj = 0;
47507 wxControl *arg1 = (wxControl *) 0 ;
47508 int result;
47509 void *argp1 = 0 ;
47510 int res1 = 0 ;
47511 PyObject *swig_obj[1] ;
47512
47513 if (!args) SWIG_fail;
47514 swig_obj[0] = args;
47515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47516 if (!SWIG_IsOK(res1)) {
47517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47518 }
47519 arg1 = reinterpret_cast< wxControl * >(argp1);
47520 {
47521 PyThreadState* __tstate = wxPyBeginAllowThreads();
47522 result = (int)((wxControl const *)arg1)->GetAlignment();
47523 wxPyEndAllowThreads(__tstate);
47524 if (PyErr_Occurred()) SWIG_fail;
47525 }
47526 resultobj = SWIG_From_int(static_cast< int >(result));
47527 return resultobj;
47528 fail:
47529 return NULL;
47530 }
47531
47532
47533 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47534 PyObject *resultobj = 0;
47535 wxControl *arg1 = (wxControl *) 0 ;
47536 wxString result;
47537 void *argp1 = 0 ;
47538 int res1 = 0 ;
47539 PyObject *swig_obj[1] ;
47540
47541 if (!args) SWIG_fail;
47542 swig_obj[0] = args;
47543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47544 if (!SWIG_IsOK(res1)) {
47545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47546 }
47547 arg1 = reinterpret_cast< wxControl * >(argp1);
47548 {
47549 PyThreadState* __tstate = wxPyBeginAllowThreads();
47550 result = ((wxControl const *)arg1)->GetLabelText();
47551 wxPyEndAllowThreads(__tstate);
47552 if (PyErr_Occurred()) SWIG_fail;
47553 }
47554 {
47555 #if wxUSE_UNICODE
47556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47557 #else
47558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47559 #endif
47560 }
47561 return resultobj;
47562 fail:
47563 return NULL;
47564 }
47565
47566
47567 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47568 PyObject *resultobj = 0;
47569 wxControl *arg1 = (wxControl *) 0 ;
47570 wxCommandEvent *arg2 = 0 ;
47571 void *argp1 = 0 ;
47572 int res1 = 0 ;
47573 void *argp2 = 0 ;
47574 int res2 = 0 ;
47575 PyObject * obj0 = 0 ;
47576 PyObject * obj1 = 0 ;
47577 char * kwnames[] = {
47578 (char *) "self",(char *) "event", NULL
47579 };
47580
47581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47583 if (!SWIG_IsOK(res1)) {
47584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47585 }
47586 arg1 = reinterpret_cast< wxControl * >(argp1);
47587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47588 if (!SWIG_IsOK(res2)) {
47589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47590 }
47591 if (!argp2) {
47592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47593 }
47594 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47595 {
47596 PyThreadState* __tstate = wxPyBeginAllowThreads();
47597 (arg1)->Command(*arg2);
47598 wxPyEndAllowThreads(__tstate);
47599 if (PyErr_Occurred()) SWIG_fail;
47600 }
47601 resultobj = SWIG_Py_Void();
47602 return resultobj;
47603 fail:
47604 return NULL;
47605 }
47606
47607
47608 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47609 PyObject *resultobj = 0;
47610 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47611 SwigValueWrapper<wxVisualAttributes > result;
47612 int val1 ;
47613 int ecode1 = 0 ;
47614 PyObject * obj0 = 0 ;
47615 char * kwnames[] = {
47616 (char *) "variant", NULL
47617 };
47618
47619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47620 if (obj0) {
47621 ecode1 = SWIG_AsVal_int(obj0, &val1);
47622 if (!SWIG_IsOK(ecode1)) {
47623 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47624 }
47625 arg1 = static_cast< wxWindowVariant >(val1);
47626 }
47627 {
47628 if (!wxPyCheckForApp()) SWIG_fail;
47629 PyThreadState* __tstate = wxPyBeginAllowThreads();
47630 result = wxControl::GetClassDefaultAttributes(arg1);
47631 wxPyEndAllowThreads(__tstate);
47632 if (PyErr_Occurred()) SWIG_fail;
47633 }
47634 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47635 return resultobj;
47636 fail:
47637 return NULL;
47638 }
47639
47640
47641 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47642 PyObject *obj;
47643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47644 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47645 return SWIG_Py_Void();
47646 }
47647
47648 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47649 return SWIG_Python_InitShadowInstance(args);
47650 }
47651
47652 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47653 PyObject *resultobj = 0;
47654 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47655 wxString *arg2 = 0 ;
47656 PyObject *arg3 = (PyObject *) NULL ;
47657 int result;
47658 void *argp1 = 0 ;
47659 int res1 = 0 ;
47660 bool temp2 = false ;
47661 PyObject * obj0 = 0 ;
47662 PyObject * obj1 = 0 ;
47663 PyObject * obj2 = 0 ;
47664 char * kwnames[] = {
47665 (char *) "self",(char *) "item",(char *) "clientData", NULL
47666 };
47667
47668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47670 if (!SWIG_IsOK(res1)) {
47671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47672 }
47673 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47674 {
47675 arg2 = wxString_in_helper(obj1);
47676 if (arg2 == NULL) SWIG_fail;
47677 temp2 = true;
47678 }
47679 if (obj2) {
47680 arg3 = obj2;
47681 }
47682 {
47683 PyThreadState* __tstate = wxPyBeginAllowThreads();
47684 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47685 wxPyEndAllowThreads(__tstate);
47686 if (PyErr_Occurred()) SWIG_fail;
47687 }
47688 resultobj = SWIG_From_int(static_cast< int >(result));
47689 {
47690 if (temp2)
47691 delete arg2;
47692 }
47693 return resultobj;
47694 fail:
47695 {
47696 if (temp2)
47697 delete arg2;
47698 }
47699 return NULL;
47700 }
47701
47702
47703 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47704 PyObject *resultobj = 0;
47705 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47706 wxArrayString *arg2 = 0 ;
47707 void *argp1 = 0 ;
47708 int res1 = 0 ;
47709 bool temp2 = false ;
47710 PyObject * obj0 = 0 ;
47711 PyObject * obj1 = 0 ;
47712 char * kwnames[] = {
47713 (char *) "self",(char *) "strings", NULL
47714 };
47715
47716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47718 if (!SWIG_IsOK(res1)) {
47719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47720 }
47721 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47722 {
47723 if (! PySequence_Check(obj1)) {
47724 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47725 SWIG_fail;
47726 }
47727 arg2 = new wxArrayString;
47728 temp2 = true;
47729 int i, len=PySequence_Length(obj1);
47730 for (i=0; i<len; i++) {
47731 PyObject* item = PySequence_GetItem(obj1, i);
47732 wxString* s = wxString_in_helper(item);
47733 if (PyErr_Occurred()) SWIG_fail;
47734 arg2->Add(*s);
47735 delete s;
47736 Py_DECREF(item);
47737 }
47738 }
47739 {
47740 PyThreadState* __tstate = wxPyBeginAllowThreads();
47741 (arg1)->Append((wxArrayString const &)*arg2);
47742 wxPyEndAllowThreads(__tstate);
47743 if (PyErr_Occurred()) SWIG_fail;
47744 }
47745 resultobj = SWIG_Py_Void();
47746 {
47747 if (temp2) delete arg2;
47748 }
47749 return resultobj;
47750 fail:
47751 {
47752 if (temp2) delete arg2;
47753 }
47754 return NULL;
47755 }
47756
47757
47758 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47759 PyObject *resultobj = 0;
47760 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47761 wxString *arg2 = 0 ;
47762 int arg3 ;
47763 PyObject *arg4 = (PyObject *) NULL ;
47764 int result;
47765 void *argp1 = 0 ;
47766 int res1 = 0 ;
47767 bool temp2 = false ;
47768 int val3 ;
47769 int ecode3 = 0 ;
47770 PyObject * obj0 = 0 ;
47771 PyObject * obj1 = 0 ;
47772 PyObject * obj2 = 0 ;
47773 PyObject * obj3 = 0 ;
47774 char * kwnames[] = {
47775 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47776 };
47777
47778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47780 if (!SWIG_IsOK(res1)) {
47781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47782 }
47783 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47784 {
47785 arg2 = wxString_in_helper(obj1);
47786 if (arg2 == NULL) SWIG_fail;
47787 temp2 = true;
47788 }
47789 ecode3 = SWIG_AsVal_int(obj2, &val3);
47790 if (!SWIG_IsOK(ecode3)) {
47791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
47792 }
47793 arg3 = static_cast< int >(val3);
47794 if (obj3) {
47795 arg4 = obj3;
47796 }
47797 {
47798 PyThreadState* __tstate = wxPyBeginAllowThreads();
47799 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47800 wxPyEndAllowThreads(__tstate);
47801 if (PyErr_Occurred()) SWIG_fail;
47802 }
47803 resultobj = SWIG_From_int(static_cast< int >(result));
47804 {
47805 if (temp2)
47806 delete arg2;
47807 }
47808 return resultobj;
47809 fail:
47810 {
47811 if (temp2)
47812 delete arg2;
47813 }
47814 return NULL;
47815 }
47816
47817
47818 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47819 PyObject *resultobj = 0;
47820 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47821 void *argp1 = 0 ;
47822 int res1 = 0 ;
47823 PyObject *swig_obj[1] ;
47824
47825 if (!args) SWIG_fail;
47826 swig_obj[0] = args;
47827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47828 if (!SWIG_IsOK(res1)) {
47829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47830 }
47831 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47832 {
47833 PyThreadState* __tstate = wxPyBeginAllowThreads();
47834 (arg1)->Clear();
47835 wxPyEndAllowThreads(__tstate);
47836 if (PyErr_Occurred()) SWIG_fail;
47837 }
47838 resultobj = SWIG_Py_Void();
47839 return resultobj;
47840 fail:
47841 return NULL;
47842 }
47843
47844
47845 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47846 PyObject *resultobj = 0;
47847 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47848 int arg2 ;
47849 void *argp1 = 0 ;
47850 int res1 = 0 ;
47851 int val2 ;
47852 int ecode2 = 0 ;
47853 PyObject * obj0 = 0 ;
47854 PyObject * obj1 = 0 ;
47855 char * kwnames[] = {
47856 (char *) "self",(char *) "n", NULL
47857 };
47858
47859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47861 if (!SWIG_IsOK(res1)) {
47862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47863 }
47864 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47865 ecode2 = SWIG_AsVal_int(obj1, &val2);
47866 if (!SWIG_IsOK(ecode2)) {
47867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
47868 }
47869 arg2 = static_cast< int >(val2);
47870 {
47871 PyThreadState* __tstate = wxPyBeginAllowThreads();
47872 (arg1)->Delete(arg2);
47873 wxPyEndAllowThreads(__tstate);
47874 if (PyErr_Occurred()) SWIG_fail;
47875 }
47876 resultobj = SWIG_Py_Void();
47877 return resultobj;
47878 fail:
47879 return NULL;
47880 }
47881
47882
47883 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47884 PyObject *resultobj = 0;
47885 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47886 int arg2 ;
47887 PyObject *result = 0 ;
47888 void *argp1 = 0 ;
47889 int res1 = 0 ;
47890 int val2 ;
47891 int ecode2 = 0 ;
47892 PyObject * obj0 = 0 ;
47893 PyObject * obj1 = 0 ;
47894 char * kwnames[] = {
47895 (char *) "self",(char *) "n", NULL
47896 };
47897
47898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47900 if (!SWIG_IsOK(res1)) {
47901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47902 }
47903 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47904 ecode2 = SWIG_AsVal_int(obj1, &val2);
47905 if (!SWIG_IsOK(ecode2)) {
47906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
47907 }
47908 arg2 = static_cast< int >(val2);
47909 {
47910 PyThreadState* __tstate = wxPyBeginAllowThreads();
47911 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47912 wxPyEndAllowThreads(__tstate);
47913 if (PyErr_Occurred()) SWIG_fail;
47914 }
47915 resultobj = result;
47916 return resultobj;
47917 fail:
47918 return NULL;
47919 }
47920
47921
47922 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47923 PyObject *resultobj = 0;
47924 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47925 int arg2 ;
47926 PyObject *arg3 = (PyObject *) 0 ;
47927 void *argp1 = 0 ;
47928 int res1 = 0 ;
47929 int val2 ;
47930 int ecode2 = 0 ;
47931 PyObject * obj0 = 0 ;
47932 PyObject * obj1 = 0 ;
47933 PyObject * obj2 = 0 ;
47934 char * kwnames[] = {
47935 (char *) "self",(char *) "n",(char *) "clientData", NULL
47936 };
47937
47938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47940 if (!SWIG_IsOK(res1)) {
47941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47942 }
47943 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47944 ecode2 = SWIG_AsVal_int(obj1, &val2);
47945 if (!SWIG_IsOK(ecode2)) {
47946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
47947 }
47948 arg2 = static_cast< int >(val2);
47949 arg3 = obj2;
47950 {
47951 PyThreadState* __tstate = wxPyBeginAllowThreads();
47952 wxItemContainer_SetClientData(arg1,arg2,arg3);
47953 wxPyEndAllowThreads(__tstate);
47954 if (PyErr_Occurred()) SWIG_fail;
47955 }
47956 resultobj = SWIG_Py_Void();
47957 return resultobj;
47958 fail:
47959 return NULL;
47960 }
47961
47962
47963 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47964 PyObject *resultobj = 0;
47965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47966 int result;
47967 void *argp1 = 0 ;
47968 int res1 = 0 ;
47969 PyObject *swig_obj[1] ;
47970
47971 if (!args) SWIG_fail;
47972 swig_obj[0] = args;
47973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47974 if (!SWIG_IsOK(res1)) {
47975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47976 }
47977 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47978 {
47979 PyThreadState* __tstate = wxPyBeginAllowThreads();
47980 result = (int)((wxItemContainer const *)arg1)->GetCount();
47981 wxPyEndAllowThreads(__tstate);
47982 if (PyErr_Occurred()) SWIG_fail;
47983 }
47984 resultobj = SWIG_From_int(static_cast< int >(result));
47985 return resultobj;
47986 fail:
47987 return NULL;
47988 }
47989
47990
47991 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47992 PyObject *resultobj = 0;
47993 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47994 bool result;
47995 void *argp1 = 0 ;
47996 int res1 = 0 ;
47997 PyObject *swig_obj[1] ;
47998
47999 if (!args) SWIG_fail;
48000 swig_obj[0] = args;
48001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48002 if (!SWIG_IsOK(res1)) {
48003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48004 }
48005 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48006 {
48007 PyThreadState* __tstate = wxPyBeginAllowThreads();
48008 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48009 wxPyEndAllowThreads(__tstate);
48010 if (PyErr_Occurred()) SWIG_fail;
48011 }
48012 {
48013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48014 }
48015 return resultobj;
48016 fail:
48017 return NULL;
48018 }
48019
48020
48021 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48022 PyObject *resultobj = 0;
48023 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48024 int arg2 ;
48025 wxString result;
48026 void *argp1 = 0 ;
48027 int res1 = 0 ;
48028 int val2 ;
48029 int ecode2 = 0 ;
48030 PyObject * obj0 = 0 ;
48031 PyObject * obj1 = 0 ;
48032 char * kwnames[] = {
48033 (char *) "self",(char *) "n", NULL
48034 };
48035
48036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48038 if (!SWIG_IsOK(res1)) {
48039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48040 }
48041 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48042 ecode2 = SWIG_AsVal_int(obj1, &val2);
48043 if (!SWIG_IsOK(ecode2)) {
48044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48045 }
48046 arg2 = static_cast< int >(val2);
48047 {
48048 PyThreadState* __tstate = wxPyBeginAllowThreads();
48049 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48050 wxPyEndAllowThreads(__tstate);
48051 if (PyErr_Occurred()) SWIG_fail;
48052 }
48053 {
48054 #if wxUSE_UNICODE
48055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48056 #else
48057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48058 #endif
48059 }
48060 return resultobj;
48061 fail:
48062 return NULL;
48063 }
48064
48065
48066 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48067 PyObject *resultobj = 0;
48068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48069 wxArrayString result;
48070 void *argp1 = 0 ;
48071 int res1 = 0 ;
48072 PyObject *swig_obj[1] ;
48073
48074 if (!args) SWIG_fail;
48075 swig_obj[0] = args;
48076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48077 if (!SWIG_IsOK(res1)) {
48078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48079 }
48080 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48081 {
48082 PyThreadState* __tstate = wxPyBeginAllowThreads();
48083 result = ((wxItemContainer const *)arg1)->GetStrings();
48084 wxPyEndAllowThreads(__tstate);
48085 if (PyErr_Occurred()) SWIG_fail;
48086 }
48087 {
48088 resultobj = wxArrayString2PyList_helper(result);
48089 }
48090 return resultobj;
48091 fail:
48092 return NULL;
48093 }
48094
48095
48096 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48097 PyObject *resultobj = 0;
48098 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48099 int arg2 ;
48100 wxString *arg3 = 0 ;
48101 void *argp1 = 0 ;
48102 int res1 = 0 ;
48103 int val2 ;
48104 int ecode2 = 0 ;
48105 bool temp3 = false ;
48106 PyObject * obj0 = 0 ;
48107 PyObject * obj1 = 0 ;
48108 PyObject * obj2 = 0 ;
48109 char * kwnames[] = {
48110 (char *) "self",(char *) "n",(char *) "s", NULL
48111 };
48112
48113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48115 if (!SWIG_IsOK(res1)) {
48116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48117 }
48118 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48119 ecode2 = SWIG_AsVal_int(obj1, &val2);
48120 if (!SWIG_IsOK(ecode2)) {
48121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48122 }
48123 arg2 = static_cast< int >(val2);
48124 {
48125 arg3 = wxString_in_helper(obj2);
48126 if (arg3 == NULL) SWIG_fail;
48127 temp3 = true;
48128 }
48129 {
48130 PyThreadState* __tstate = wxPyBeginAllowThreads();
48131 (arg1)->SetString(arg2,(wxString const &)*arg3);
48132 wxPyEndAllowThreads(__tstate);
48133 if (PyErr_Occurred()) SWIG_fail;
48134 }
48135 resultobj = SWIG_Py_Void();
48136 {
48137 if (temp3)
48138 delete arg3;
48139 }
48140 return resultobj;
48141 fail:
48142 {
48143 if (temp3)
48144 delete arg3;
48145 }
48146 return NULL;
48147 }
48148
48149
48150 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48151 PyObject *resultobj = 0;
48152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48153 wxString *arg2 = 0 ;
48154 int result;
48155 void *argp1 = 0 ;
48156 int res1 = 0 ;
48157 bool temp2 = false ;
48158 PyObject * obj0 = 0 ;
48159 PyObject * obj1 = 0 ;
48160 char * kwnames[] = {
48161 (char *) "self",(char *) "s", NULL
48162 };
48163
48164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48166 if (!SWIG_IsOK(res1)) {
48167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48168 }
48169 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48170 {
48171 arg2 = wxString_in_helper(obj1);
48172 if (arg2 == NULL) SWIG_fail;
48173 temp2 = true;
48174 }
48175 {
48176 PyThreadState* __tstate = wxPyBeginAllowThreads();
48177 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48178 wxPyEndAllowThreads(__tstate);
48179 if (PyErr_Occurred()) SWIG_fail;
48180 }
48181 resultobj = SWIG_From_int(static_cast< int >(result));
48182 {
48183 if (temp2)
48184 delete arg2;
48185 }
48186 return resultobj;
48187 fail:
48188 {
48189 if (temp2)
48190 delete arg2;
48191 }
48192 return NULL;
48193 }
48194
48195
48196 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48197 PyObject *resultobj = 0;
48198 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48199 int arg2 ;
48200 void *argp1 = 0 ;
48201 int res1 = 0 ;
48202 int val2 ;
48203 int ecode2 = 0 ;
48204 PyObject * obj0 = 0 ;
48205 PyObject * obj1 = 0 ;
48206 char * kwnames[] = {
48207 (char *) "self",(char *) "n", NULL
48208 };
48209
48210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48212 if (!SWIG_IsOK(res1)) {
48213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48214 }
48215 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48216 ecode2 = SWIG_AsVal_int(obj1, &val2);
48217 if (!SWIG_IsOK(ecode2)) {
48218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48219 }
48220 arg2 = static_cast< int >(val2);
48221 {
48222 PyThreadState* __tstate = wxPyBeginAllowThreads();
48223 (arg1)->SetSelection(arg2);
48224 wxPyEndAllowThreads(__tstate);
48225 if (PyErr_Occurred()) SWIG_fail;
48226 }
48227 resultobj = SWIG_Py_Void();
48228 return resultobj;
48229 fail:
48230 return NULL;
48231 }
48232
48233
48234 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48235 PyObject *resultobj = 0;
48236 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48237 int result;
48238 void *argp1 = 0 ;
48239 int res1 = 0 ;
48240 PyObject *swig_obj[1] ;
48241
48242 if (!args) SWIG_fail;
48243 swig_obj[0] = args;
48244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48245 if (!SWIG_IsOK(res1)) {
48246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48247 }
48248 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48249 {
48250 PyThreadState* __tstate = wxPyBeginAllowThreads();
48251 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48252 wxPyEndAllowThreads(__tstate);
48253 if (PyErr_Occurred()) SWIG_fail;
48254 }
48255 resultobj = SWIG_From_int(static_cast< int >(result));
48256 return resultobj;
48257 fail:
48258 return NULL;
48259 }
48260
48261
48262 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48263 PyObject *resultobj = 0;
48264 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48265 wxString *arg2 = 0 ;
48266 bool result;
48267 void *argp1 = 0 ;
48268 int res1 = 0 ;
48269 bool temp2 = false ;
48270 PyObject * obj0 = 0 ;
48271 PyObject * obj1 = 0 ;
48272 char * kwnames[] = {
48273 (char *) "self",(char *) "s", NULL
48274 };
48275
48276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48278 if (!SWIG_IsOK(res1)) {
48279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48280 }
48281 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48282 {
48283 arg2 = wxString_in_helper(obj1);
48284 if (arg2 == NULL) SWIG_fail;
48285 temp2 = true;
48286 }
48287 {
48288 PyThreadState* __tstate = wxPyBeginAllowThreads();
48289 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48290 wxPyEndAllowThreads(__tstate);
48291 if (PyErr_Occurred()) SWIG_fail;
48292 }
48293 {
48294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48295 }
48296 {
48297 if (temp2)
48298 delete arg2;
48299 }
48300 return resultobj;
48301 fail:
48302 {
48303 if (temp2)
48304 delete arg2;
48305 }
48306 return NULL;
48307 }
48308
48309
48310 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48311 PyObject *resultobj = 0;
48312 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48313 wxString result;
48314 void *argp1 = 0 ;
48315 int res1 = 0 ;
48316 PyObject *swig_obj[1] ;
48317
48318 if (!args) SWIG_fail;
48319 swig_obj[0] = args;
48320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48321 if (!SWIG_IsOK(res1)) {
48322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48323 }
48324 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48325 {
48326 PyThreadState* __tstate = wxPyBeginAllowThreads();
48327 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48328 wxPyEndAllowThreads(__tstate);
48329 if (PyErr_Occurred()) SWIG_fail;
48330 }
48331 {
48332 #if wxUSE_UNICODE
48333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48334 #else
48335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48336 #endif
48337 }
48338 return resultobj;
48339 fail:
48340 return NULL;
48341 }
48342
48343
48344 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48345 PyObject *resultobj = 0;
48346 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48347 int arg2 ;
48348 void *argp1 = 0 ;
48349 int res1 = 0 ;
48350 int val2 ;
48351 int ecode2 = 0 ;
48352 PyObject * obj0 = 0 ;
48353 PyObject * obj1 = 0 ;
48354 char * kwnames[] = {
48355 (char *) "self",(char *) "n", NULL
48356 };
48357
48358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48360 if (!SWIG_IsOK(res1)) {
48361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48362 }
48363 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48364 ecode2 = SWIG_AsVal_int(obj1, &val2);
48365 if (!SWIG_IsOK(ecode2)) {
48366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48367 }
48368 arg2 = static_cast< int >(val2);
48369 {
48370 PyThreadState* __tstate = wxPyBeginAllowThreads();
48371 (arg1)->Select(arg2);
48372 wxPyEndAllowThreads(__tstate);
48373 if (PyErr_Occurred()) SWIG_fail;
48374 }
48375 resultobj = SWIG_Py_Void();
48376 return resultobj;
48377 fail:
48378 return NULL;
48379 }
48380
48381
48382 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48383 PyObject *obj;
48384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48385 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48386 return SWIG_Py_Void();
48387 }
48388
48389 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48390 PyObject *obj;
48391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48392 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48393 return SWIG_Py_Void();
48394 }
48395
48396 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48397 PyObject *resultobj = 0;
48398 wxSizerItem *result = 0 ;
48399
48400 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48401 {
48402 PyThreadState* __tstate = wxPyBeginAllowThreads();
48403 result = (wxSizerItem *)new wxSizerItem();
48404 wxPyEndAllowThreads(__tstate);
48405 if (PyErr_Occurred()) SWIG_fail;
48406 }
48407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48408 return resultobj;
48409 fail:
48410 return NULL;
48411 }
48412
48413
48414 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48415 PyObject *resultobj = 0;
48416 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48417 void *argp1 = 0 ;
48418 int res1 = 0 ;
48419 PyObject *swig_obj[1] ;
48420
48421 if (!args) SWIG_fail;
48422 swig_obj[0] = args;
48423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48424 if (!SWIG_IsOK(res1)) {
48425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48426 }
48427 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48428 {
48429 PyThreadState* __tstate = wxPyBeginAllowThreads();
48430 delete arg1;
48431
48432 wxPyEndAllowThreads(__tstate);
48433 if (PyErr_Occurred()) SWIG_fail;
48434 }
48435 resultobj = SWIG_Py_Void();
48436 return resultobj;
48437 fail:
48438 return NULL;
48439 }
48440
48441
48442 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48443 PyObject *resultobj = 0;
48444 wxWindow *arg1 = (wxWindow *) 0 ;
48445 int arg2 ;
48446 int arg3 ;
48447 int arg4 ;
48448 PyObject *arg5 = (PyObject *) NULL ;
48449 wxSizerItem *result = 0 ;
48450 void *argp1 = 0 ;
48451 int res1 = 0 ;
48452 int val2 ;
48453 int ecode2 = 0 ;
48454 int val3 ;
48455 int ecode3 = 0 ;
48456 int val4 ;
48457 int ecode4 = 0 ;
48458 PyObject * obj0 = 0 ;
48459 PyObject * obj1 = 0 ;
48460 PyObject * obj2 = 0 ;
48461 PyObject * obj3 = 0 ;
48462 PyObject * obj4 = 0 ;
48463 char * kwnames[] = {
48464 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48465 };
48466
48467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48469 if (!SWIG_IsOK(res1)) {
48470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48471 }
48472 arg1 = reinterpret_cast< wxWindow * >(argp1);
48473 ecode2 = SWIG_AsVal_int(obj1, &val2);
48474 if (!SWIG_IsOK(ecode2)) {
48475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48476 }
48477 arg2 = static_cast< int >(val2);
48478 ecode3 = SWIG_AsVal_int(obj2, &val3);
48479 if (!SWIG_IsOK(ecode3)) {
48480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48481 }
48482 arg3 = static_cast< int >(val3);
48483 ecode4 = SWIG_AsVal_int(obj3, &val4);
48484 if (!SWIG_IsOK(ecode4)) {
48485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48486 }
48487 arg4 = static_cast< int >(val4);
48488 if (obj4) {
48489 arg5 = obj4;
48490 }
48491 {
48492 PyThreadState* __tstate = wxPyBeginAllowThreads();
48493 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48494 wxPyEndAllowThreads(__tstate);
48495 if (PyErr_Occurred()) SWIG_fail;
48496 }
48497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48498 return resultobj;
48499 fail:
48500 return NULL;
48501 }
48502
48503
48504 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48505 PyObject *resultobj = 0;
48506 int arg1 ;
48507 int arg2 ;
48508 int arg3 ;
48509 int arg4 ;
48510 int arg5 ;
48511 PyObject *arg6 = (PyObject *) NULL ;
48512 wxSizerItem *result = 0 ;
48513 int val1 ;
48514 int ecode1 = 0 ;
48515 int val2 ;
48516 int ecode2 = 0 ;
48517 int val3 ;
48518 int ecode3 = 0 ;
48519 int val4 ;
48520 int ecode4 = 0 ;
48521 int val5 ;
48522 int ecode5 = 0 ;
48523 PyObject * obj0 = 0 ;
48524 PyObject * obj1 = 0 ;
48525 PyObject * obj2 = 0 ;
48526 PyObject * obj3 = 0 ;
48527 PyObject * obj4 = 0 ;
48528 PyObject * obj5 = 0 ;
48529 char * kwnames[] = {
48530 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48531 };
48532
48533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48534 ecode1 = SWIG_AsVal_int(obj0, &val1);
48535 if (!SWIG_IsOK(ecode1)) {
48536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48537 }
48538 arg1 = static_cast< int >(val1);
48539 ecode2 = SWIG_AsVal_int(obj1, &val2);
48540 if (!SWIG_IsOK(ecode2)) {
48541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48542 }
48543 arg2 = static_cast< int >(val2);
48544 ecode3 = SWIG_AsVal_int(obj2, &val3);
48545 if (!SWIG_IsOK(ecode3)) {
48546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48547 }
48548 arg3 = static_cast< int >(val3);
48549 ecode4 = SWIG_AsVal_int(obj3, &val4);
48550 if (!SWIG_IsOK(ecode4)) {
48551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48552 }
48553 arg4 = static_cast< int >(val4);
48554 ecode5 = SWIG_AsVal_int(obj4, &val5);
48555 if (!SWIG_IsOK(ecode5)) {
48556 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48557 }
48558 arg5 = static_cast< int >(val5);
48559 if (obj5) {
48560 arg6 = obj5;
48561 }
48562 {
48563 PyThreadState* __tstate = wxPyBeginAllowThreads();
48564 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48565 wxPyEndAllowThreads(__tstate);
48566 if (PyErr_Occurred()) SWIG_fail;
48567 }
48568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48569 return resultobj;
48570 fail:
48571 return NULL;
48572 }
48573
48574
48575 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48576 PyObject *resultobj = 0;
48577 wxSizer *arg1 = (wxSizer *) 0 ;
48578 int arg2 ;
48579 int arg3 ;
48580 int arg4 ;
48581 PyObject *arg5 = (PyObject *) NULL ;
48582 wxSizerItem *result = 0 ;
48583 int res1 = 0 ;
48584 int val2 ;
48585 int ecode2 = 0 ;
48586 int val3 ;
48587 int ecode3 = 0 ;
48588 int val4 ;
48589 int ecode4 = 0 ;
48590 PyObject * obj0 = 0 ;
48591 PyObject * obj1 = 0 ;
48592 PyObject * obj2 = 0 ;
48593 PyObject * obj3 = 0 ;
48594 PyObject * obj4 = 0 ;
48595 char * kwnames[] = {
48596 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48597 };
48598
48599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48600 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48601 if (!SWIG_IsOK(res1)) {
48602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48603 }
48604 ecode2 = SWIG_AsVal_int(obj1, &val2);
48605 if (!SWIG_IsOK(ecode2)) {
48606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48607 }
48608 arg2 = static_cast< int >(val2);
48609 ecode3 = SWIG_AsVal_int(obj2, &val3);
48610 if (!SWIG_IsOK(ecode3)) {
48611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48612 }
48613 arg3 = static_cast< int >(val3);
48614 ecode4 = SWIG_AsVal_int(obj3, &val4);
48615 if (!SWIG_IsOK(ecode4)) {
48616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48617 }
48618 arg4 = static_cast< int >(val4);
48619 if (obj4) {
48620 arg5 = obj4;
48621 }
48622 {
48623 PyThreadState* __tstate = wxPyBeginAllowThreads();
48624 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48625 wxPyEndAllowThreads(__tstate);
48626 if (PyErr_Occurred()) SWIG_fail;
48627 }
48628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48629 return resultobj;
48630 fail:
48631 return NULL;
48632 }
48633
48634
48635 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48636 PyObject *resultobj = 0;
48637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48638 void *argp1 = 0 ;
48639 int res1 = 0 ;
48640 PyObject *swig_obj[1] ;
48641
48642 if (!args) SWIG_fail;
48643 swig_obj[0] = args;
48644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48647 }
48648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48649 {
48650 PyThreadState* __tstate = wxPyBeginAllowThreads();
48651 (arg1)->DeleteWindows();
48652 wxPyEndAllowThreads(__tstate);
48653 if (PyErr_Occurred()) SWIG_fail;
48654 }
48655 resultobj = SWIG_Py_Void();
48656 return resultobj;
48657 fail:
48658 return NULL;
48659 }
48660
48661
48662 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48663 PyObject *resultobj = 0;
48664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48665 void *argp1 = 0 ;
48666 int res1 = 0 ;
48667 PyObject *swig_obj[1] ;
48668
48669 if (!args) SWIG_fail;
48670 swig_obj[0] = args;
48671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48672 if (!SWIG_IsOK(res1)) {
48673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48674 }
48675 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48676 {
48677 PyThreadState* __tstate = wxPyBeginAllowThreads();
48678 (arg1)->DetachSizer();
48679 wxPyEndAllowThreads(__tstate);
48680 if (PyErr_Occurred()) SWIG_fail;
48681 }
48682 resultobj = SWIG_Py_Void();
48683 return resultobj;
48684 fail:
48685 return NULL;
48686 }
48687
48688
48689 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48690 PyObject *resultobj = 0;
48691 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48692 wxSize result;
48693 void *argp1 = 0 ;
48694 int res1 = 0 ;
48695 PyObject *swig_obj[1] ;
48696
48697 if (!args) SWIG_fail;
48698 swig_obj[0] = args;
48699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48700 if (!SWIG_IsOK(res1)) {
48701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48702 }
48703 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48704 {
48705 PyThreadState* __tstate = wxPyBeginAllowThreads();
48706 result = (arg1)->GetSize();
48707 wxPyEndAllowThreads(__tstate);
48708 if (PyErr_Occurred()) SWIG_fail;
48709 }
48710 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48711 return resultobj;
48712 fail:
48713 return NULL;
48714 }
48715
48716
48717 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48718 PyObject *resultobj = 0;
48719 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48720 wxSize result;
48721 void *argp1 = 0 ;
48722 int res1 = 0 ;
48723 PyObject *swig_obj[1] ;
48724
48725 if (!args) SWIG_fail;
48726 swig_obj[0] = args;
48727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48728 if (!SWIG_IsOK(res1)) {
48729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48730 }
48731 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48732 {
48733 PyThreadState* __tstate = wxPyBeginAllowThreads();
48734 result = (arg1)->CalcMin();
48735 wxPyEndAllowThreads(__tstate);
48736 if (PyErr_Occurred()) SWIG_fail;
48737 }
48738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48739 return resultobj;
48740 fail:
48741 return NULL;
48742 }
48743
48744
48745 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48746 PyObject *resultobj = 0;
48747 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48748 wxPoint *arg2 = 0 ;
48749 wxSize *arg3 = 0 ;
48750 void *argp1 = 0 ;
48751 int res1 = 0 ;
48752 wxPoint temp2 ;
48753 wxSize temp3 ;
48754 PyObject * obj0 = 0 ;
48755 PyObject * obj1 = 0 ;
48756 PyObject * obj2 = 0 ;
48757 char * kwnames[] = {
48758 (char *) "self",(char *) "pos",(char *) "size", NULL
48759 };
48760
48761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48763 if (!SWIG_IsOK(res1)) {
48764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48765 }
48766 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48767 {
48768 arg2 = &temp2;
48769 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48770 }
48771 {
48772 arg3 = &temp3;
48773 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48774 }
48775 {
48776 PyThreadState* __tstate = wxPyBeginAllowThreads();
48777 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48778 wxPyEndAllowThreads(__tstate);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 resultobj = SWIG_Py_Void();
48782 return resultobj;
48783 fail:
48784 return NULL;
48785 }
48786
48787
48788 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48789 PyObject *resultobj = 0;
48790 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48791 wxSize result;
48792 void *argp1 = 0 ;
48793 int res1 = 0 ;
48794 PyObject *swig_obj[1] ;
48795
48796 if (!args) SWIG_fail;
48797 swig_obj[0] = args;
48798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48799 if (!SWIG_IsOK(res1)) {
48800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48801 }
48802 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48803 {
48804 PyThreadState* __tstate = wxPyBeginAllowThreads();
48805 result = (arg1)->GetMinSize();
48806 wxPyEndAllowThreads(__tstate);
48807 if (PyErr_Occurred()) SWIG_fail;
48808 }
48809 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48810 return resultobj;
48811 fail:
48812 return NULL;
48813 }
48814
48815
48816 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48817 PyObject *resultobj = 0;
48818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48819 wxSize result;
48820 void *argp1 = 0 ;
48821 int res1 = 0 ;
48822 PyObject *swig_obj[1] ;
48823
48824 if (!args) SWIG_fail;
48825 swig_obj[0] = args;
48826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48827 if (!SWIG_IsOK(res1)) {
48828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48829 }
48830 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48831 {
48832 PyThreadState* __tstate = wxPyBeginAllowThreads();
48833 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48834 wxPyEndAllowThreads(__tstate);
48835 if (PyErr_Occurred()) SWIG_fail;
48836 }
48837 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48838 return resultobj;
48839 fail:
48840 return NULL;
48841 }
48842
48843
48844 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48845 PyObject *resultobj = 0;
48846 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48847 int arg2 ;
48848 int arg3 ;
48849 void *argp1 = 0 ;
48850 int res1 = 0 ;
48851 int val2 ;
48852 int ecode2 = 0 ;
48853 int val3 ;
48854 int ecode3 = 0 ;
48855 PyObject * obj0 = 0 ;
48856 PyObject * obj1 = 0 ;
48857 PyObject * obj2 = 0 ;
48858 char * kwnames[] = {
48859 (char *) "self",(char *) "x",(char *) "y", NULL
48860 };
48861
48862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48864 if (!SWIG_IsOK(res1)) {
48865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48866 }
48867 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48868 ecode2 = SWIG_AsVal_int(obj1, &val2);
48869 if (!SWIG_IsOK(ecode2)) {
48870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48871 }
48872 arg2 = static_cast< int >(val2);
48873 ecode3 = SWIG_AsVal_int(obj2, &val3);
48874 if (!SWIG_IsOK(ecode3)) {
48875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48876 }
48877 arg3 = static_cast< int >(val3);
48878 {
48879 PyThreadState* __tstate = wxPyBeginAllowThreads();
48880 (arg1)->SetInitSize(arg2,arg3);
48881 wxPyEndAllowThreads(__tstate);
48882 if (PyErr_Occurred()) SWIG_fail;
48883 }
48884 resultobj = SWIG_Py_Void();
48885 return resultobj;
48886 fail:
48887 return NULL;
48888 }
48889
48890
48891 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48892 PyObject *resultobj = 0;
48893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48894 int arg2 ;
48895 int arg3 ;
48896 void *argp1 = 0 ;
48897 int res1 = 0 ;
48898 int val2 ;
48899 int ecode2 = 0 ;
48900 int val3 ;
48901 int ecode3 = 0 ;
48902 PyObject * obj0 = 0 ;
48903 PyObject * obj1 = 0 ;
48904 PyObject * obj2 = 0 ;
48905 char * kwnames[] = {
48906 (char *) "self",(char *) "width",(char *) "height", NULL
48907 };
48908
48909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48911 if (!SWIG_IsOK(res1)) {
48912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48913 }
48914 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48915 ecode2 = SWIG_AsVal_int(obj1, &val2);
48916 if (!SWIG_IsOK(ecode2)) {
48917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48918 }
48919 arg2 = static_cast< int >(val2);
48920 ecode3 = SWIG_AsVal_int(obj2, &val3);
48921 if (!SWIG_IsOK(ecode3)) {
48922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48923 }
48924 arg3 = static_cast< int >(val3);
48925 {
48926 PyThreadState* __tstate = wxPyBeginAllowThreads();
48927 (arg1)->SetRatio(arg2,arg3);
48928 wxPyEndAllowThreads(__tstate);
48929 if (PyErr_Occurred()) SWIG_fail;
48930 }
48931 resultobj = SWIG_Py_Void();
48932 return resultobj;
48933 fail:
48934 return NULL;
48935 }
48936
48937
48938 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48939 PyObject *resultobj = 0;
48940 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48941 wxSize *arg2 = 0 ;
48942 void *argp1 = 0 ;
48943 int res1 = 0 ;
48944 wxSize temp2 ;
48945 PyObject * obj0 = 0 ;
48946 PyObject * obj1 = 0 ;
48947 char * kwnames[] = {
48948 (char *) "self",(char *) "size", NULL
48949 };
48950
48951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48953 if (!SWIG_IsOK(res1)) {
48954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48955 }
48956 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48957 {
48958 arg2 = &temp2;
48959 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48960 }
48961 {
48962 PyThreadState* __tstate = wxPyBeginAllowThreads();
48963 (arg1)->SetRatio((wxSize const &)*arg2);
48964 wxPyEndAllowThreads(__tstate);
48965 if (PyErr_Occurred()) SWIG_fail;
48966 }
48967 resultobj = SWIG_Py_Void();
48968 return resultobj;
48969 fail:
48970 return NULL;
48971 }
48972
48973
48974 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48975 PyObject *resultobj = 0;
48976 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48977 float arg2 ;
48978 void *argp1 = 0 ;
48979 int res1 = 0 ;
48980 float val2 ;
48981 int ecode2 = 0 ;
48982 PyObject * obj0 = 0 ;
48983 PyObject * obj1 = 0 ;
48984 char * kwnames[] = {
48985 (char *) "self",(char *) "ratio", NULL
48986 };
48987
48988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48990 if (!SWIG_IsOK(res1)) {
48991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48992 }
48993 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48994 ecode2 = SWIG_AsVal_float(obj1, &val2);
48995 if (!SWIG_IsOK(ecode2)) {
48996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48997 }
48998 arg2 = static_cast< float >(val2);
48999 {
49000 PyThreadState* __tstate = wxPyBeginAllowThreads();
49001 (arg1)->SetRatio(arg2);
49002 wxPyEndAllowThreads(__tstate);
49003 if (PyErr_Occurred()) SWIG_fail;
49004 }
49005 resultobj = SWIG_Py_Void();
49006 return resultobj;
49007 fail:
49008 return NULL;
49009 }
49010
49011
49012 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49013 PyObject *resultobj = 0;
49014 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49015 float result;
49016 void *argp1 = 0 ;
49017 int res1 = 0 ;
49018 PyObject *swig_obj[1] ;
49019
49020 if (!args) SWIG_fail;
49021 swig_obj[0] = args;
49022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49023 if (!SWIG_IsOK(res1)) {
49024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49025 }
49026 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49027 {
49028 PyThreadState* __tstate = wxPyBeginAllowThreads();
49029 result = (float)(arg1)->GetRatio();
49030 wxPyEndAllowThreads(__tstate);
49031 if (PyErr_Occurred()) SWIG_fail;
49032 }
49033 resultobj = SWIG_From_float(static_cast< float >(result));
49034 return resultobj;
49035 fail:
49036 return NULL;
49037 }
49038
49039
49040 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49041 PyObject *resultobj = 0;
49042 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49043 wxRect result;
49044 void *argp1 = 0 ;
49045 int res1 = 0 ;
49046 PyObject *swig_obj[1] ;
49047
49048 if (!args) SWIG_fail;
49049 swig_obj[0] = args;
49050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49051 if (!SWIG_IsOK(res1)) {
49052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49053 }
49054 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49055 {
49056 PyThreadState* __tstate = wxPyBeginAllowThreads();
49057 result = (arg1)->GetRect();
49058 wxPyEndAllowThreads(__tstate);
49059 if (PyErr_Occurred()) SWIG_fail;
49060 }
49061 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49062 return resultobj;
49063 fail:
49064 return NULL;
49065 }
49066
49067
49068 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49069 PyObject *resultobj = 0;
49070 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49071 bool result;
49072 void *argp1 = 0 ;
49073 int res1 = 0 ;
49074 PyObject *swig_obj[1] ;
49075
49076 if (!args) SWIG_fail;
49077 swig_obj[0] = args;
49078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49079 if (!SWIG_IsOK(res1)) {
49080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49081 }
49082 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49083 {
49084 PyThreadState* __tstate = wxPyBeginAllowThreads();
49085 result = (bool)(arg1)->IsWindow();
49086 wxPyEndAllowThreads(__tstate);
49087 if (PyErr_Occurred()) SWIG_fail;
49088 }
49089 {
49090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49091 }
49092 return resultobj;
49093 fail:
49094 return NULL;
49095 }
49096
49097
49098 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49099 PyObject *resultobj = 0;
49100 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49101 bool result;
49102 void *argp1 = 0 ;
49103 int res1 = 0 ;
49104 PyObject *swig_obj[1] ;
49105
49106 if (!args) SWIG_fail;
49107 swig_obj[0] = args;
49108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49109 if (!SWIG_IsOK(res1)) {
49110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49111 }
49112 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49113 {
49114 PyThreadState* __tstate = wxPyBeginAllowThreads();
49115 result = (bool)(arg1)->IsSizer();
49116 wxPyEndAllowThreads(__tstate);
49117 if (PyErr_Occurred()) SWIG_fail;
49118 }
49119 {
49120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49121 }
49122 return resultobj;
49123 fail:
49124 return NULL;
49125 }
49126
49127
49128 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49129 PyObject *resultobj = 0;
49130 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49131 bool result;
49132 void *argp1 = 0 ;
49133 int res1 = 0 ;
49134 PyObject *swig_obj[1] ;
49135
49136 if (!args) SWIG_fail;
49137 swig_obj[0] = args;
49138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49139 if (!SWIG_IsOK(res1)) {
49140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49141 }
49142 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49143 {
49144 PyThreadState* __tstate = wxPyBeginAllowThreads();
49145 result = (bool)(arg1)->IsSpacer();
49146 wxPyEndAllowThreads(__tstate);
49147 if (PyErr_Occurred()) SWIG_fail;
49148 }
49149 {
49150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49151 }
49152 return resultobj;
49153 fail:
49154 return NULL;
49155 }
49156
49157
49158 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49159 PyObject *resultobj = 0;
49160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49161 int arg2 ;
49162 void *argp1 = 0 ;
49163 int res1 = 0 ;
49164 int val2 ;
49165 int ecode2 = 0 ;
49166 PyObject * obj0 = 0 ;
49167 PyObject * obj1 = 0 ;
49168 char * kwnames[] = {
49169 (char *) "self",(char *) "proportion", NULL
49170 };
49171
49172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49174 if (!SWIG_IsOK(res1)) {
49175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49176 }
49177 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49178 ecode2 = SWIG_AsVal_int(obj1, &val2);
49179 if (!SWIG_IsOK(ecode2)) {
49180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49181 }
49182 arg2 = static_cast< int >(val2);
49183 {
49184 PyThreadState* __tstate = wxPyBeginAllowThreads();
49185 (arg1)->SetProportion(arg2);
49186 wxPyEndAllowThreads(__tstate);
49187 if (PyErr_Occurred()) SWIG_fail;
49188 }
49189 resultobj = SWIG_Py_Void();
49190 return resultobj;
49191 fail:
49192 return NULL;
49193 }
49194
49195
49196 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49197 PyObject *resultobj = 0;
49198 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49199 int result;
49200 void *argp1 = 0 ;
49201 int res1 = 0 ;
49202 PyObject *swig_obj[1] ;
49203
49204 if (!args) SWIG_fail;
49205 swig_obj[0] = args;
49206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49207 if (!SWIG_IsOK(res1)) {
49208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49209 }
49210 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49211 {
49212 PyThreadState* __tstate = wxPyBeginAllowThreads();
49213 result = (int)(arg1)->GetProportion();
49214 wxPyEndAllowThreads(__tstate);
49215 if (PyErr_Occurred()) SWIG_fail;
49216 }
49217 resultobj = SWIG_From_int(static_cast< int >(result));
49218 return resultobj;
49219 fail:
49220 return NULL;
49221 }
49222
49223
49224 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49225 PyObject *resultobj = 0;
49226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49227 int arg2 ;
49228 void *argp1 = 0 ;
49229 int res1 = 0 ;
49230 int val2 ;
49231 int ecode2 = 0 ;
49232 PyObject * obj0 = 0 ;
49233 PyObject * obj1 = 0 ;
49234 char * kwnames[] = {
49235 (char *) "self",(char *) "flag", NULL
49236 };
49237
49238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49240 if (!SWIG_IsOK(res1)) {
49241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49242 }
49243 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49244 ecode2 = SWIG_AsVal_int(obj1, &val2);
49245 if (!SWIG_IsOK(ecode2)) {
49246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49247 }
49248 arg2 = static_cast< int >(val2);
49249 {
49250 PyThreadState* __tstate = wxPyBeginAllowThreads();
49251 (arg1)->SetFlag(arg2);
49252 wxPyEndAllowThreads(__tstate);
49253 if (PyErr_Occurred()) SWIG_fail;
49254 }
49255 resultobj = SWIG_Py_Void();
49256 return resultobj;
49257 fail:
49258 return NULL;
49259 }
49260
49261
49262 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49263 PyObject *resultobj = 0;
49264 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49265 int result;
49266 void *argp1 = 0 ;
49267 int res1 = 0 ;
49268 PyObject *swig_obj[1] ;
49269
49270 if (!args) SWIG_fail;
49271 swig_obj[0] = args;
49272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49273 if (!SWIG_IsOK(res1)) {
49274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49275 }
49276 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49277 {
49278 PyThreadState* __tstate = wxPyBeginAllowThreads();
49279 result = (int)(arg1)->GetFlag();
49280 wxPyEndAllowThreads(__tstate);
49281 if (PyErr_Occurred()) SWIG_fail;
49282 }
49283 resultobj = SWIG_From_int(static_cast< int >(result));
49284 return resultobj;
49285 fail:
49286 return NULL;
49287 }
49288
49289
49290 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49291 PyObject *resultobj = 0;
49292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49293 int arg2 ;
49294 void *argp1 = 0 ;
49295 int res1 = 0 ;
49296 int val2 ;
49297 int ecode2 = 0 ;
49298 PyObject * obj0 = 0 ;
49299 PyObject * obj1 = 0 ;
49300 char * kwnames[] = {
49301 (char *) "self",(char *) "border", NULL
49302 };
49303
49304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49306 if (!SWIG_IsOK(res1)) {
49307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49308 }
49309 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49310 ecode2 = SWIG_AsVal_int(obj1, &val2);
49311 if (!SWIG_IsOK(ecode2)) {
49312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49313 }
49314 arg2 = static_cast< int >(val2);
49315 {
49316 PyThreadState* __tstate = wxPyBeginAllowThreads();
49317 (arg1)->SetBorder(arg2);
49318 wxPyEndAllowThreads(__tstate);
49319 if (PyErr_Occurred()) SWIG_fail;
49320 }
49321 resultobj = SWIG_Py_Void();
49322 return resultobj;
49323 fail:
49324 return NULL;
49325 }
49326
49327
49328 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49329 PyObject *resultobj = 0;
49330 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49331 int result;
49332 void *argp1 = 0 ;
49333 int res1 = 0 ;
49334 PyObject *swig_obj[1] ;
49335
49336 if (!args) SWIG_fail;
49337 swig_obj[0] = args;
49338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49339 if (!SWIG_IsOK(res1)) {
49340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49341 }
49342 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49343 {
49344 PyThreadState* __tstate = wxPyBeginAllowThreads();
49345 result = (int)(arg1)->GetBorder();
49346 wxPyEndAllowThreads(__tstate);
49347 if (PyErr_Occurred()) SWIG_fail;
49348 }
49349 resultobj = SWIG_From_int(static_cast< int >(result));
49350 return resultobj;
49351 fail:
49352 return NULL;
49353 }
49354
49355
49356 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49357 PyObject *resultobj = 0;
49358 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49359 wxWindow *result = 0 ;
49360 void *argp1 = 0 ;
49361 int res1 = 0 ;
49362 PyObject *swig_obj[1] ;
49363
49364 if (!args) SWIG_fail;
49365 swig_obj[0] = args;
49366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49367 if (!SWIG_IsOK(res1)) {
49368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49369 }
49370 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49371 {
49372 PyThreadState* __tstate = wxPyBeginAllowThreads();
49373 result = (wxWindow *)(arg1)->GetWindow();
49374 wxPyEndAllowThreads(__tstate);
49375 if (PyErr_Occurred()) SWIG_fail;
49376 }
49377 {
49378 resultobj = wxPyMake_wxObject(result, 0);
49379 }
49380 return resultobj;
49381 fail:
49382 return NULL;
49383 }
49384
49385
49386 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49387 PyObject *resultobj = 0;
49388 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49389 wxWindow *arg2 = (wxWindow *) 0 ;
49390 void *argp1 = 0 ;
49391 int res1 = 0 ;
49392 void *argp2 = 0 ;
49393 int res2 = 0 ;
49394 PyObject * obj0 = 0 ;
49395 PyObject * obj1 = 0 ;
49396 char * kwnames[] = {
49397 (char *) "self",(char *) "window", NULL
49398 };
49399
49400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49402 if (!SWIG_IsOK(res1)) {
49403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49404 }
49405 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49407 if (!SWIG_IsOK(res2)) {
49408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49409 }
49410 arg2 = reinterpret_cast< wxWindow * >(argp2);
49411 {
49412 PyThreadState* __tstate = wxPyBeginAllowThreads();
49413 (arg1)->SetWindow(arg2);
49414 wxPyEndAllowThreads(__tstate);
49415 if (PyErr_Occurred()) SWIG_fail;
49416 }
49417 resultobj = SWIG_Py_Void();
49418 return resultobj;
49419 fail:
49420 return NULL;
49421 }
49422
49423
49424 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49425 PyObject *resultobj = 0;
49426 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49427 wxSizer *result = 0 ;
49428 void *argp1 = 0 ;
49429 int res1 = 0 ;
49430 PyObject *swig_obj[1] ;
49431
49432 if (!args) SWIG_fail;
49433 swig_obj[0] = args;
49434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49435 if (!SWIG_IsOK(res1)) {
49436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49437 }
49438 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49439 {
49440 PyThreadState* __tstate = wxPyBeginAllowThreads();
49441 result = (wxSizer *)(arg1)->GetSizer();
49442 wxPyEndAllowThreads(__tstate);
49443 if (PyErr_Occurred()) SWIG_fail;
49444 }
49445 {
49446 resultobj = wxPyMake_wxObject(result, (bool)0);
49447 }
49448 return resultobj;
49449 fail:
49450 return NULL;
49451 }
49452
49453
49454 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49455 PyObject *resultobj = 0;
49456 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49457 wxSizer *arg2 = (wxSizer *) 0 ;
49458 void *argp1 = 0 ;
49459 int res1 = 0 ;
49460 int res2 = 0 ;
49461 PyObject * obj0 = 0 ;
49462 PyObject * obj1 = 0 ;
49463 char * kwnames[] = {
49464 (char *) "self",(char *) "sizer", NULL
49465 };
49466
49467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49469 if (!SWIG_IsOK(res1)) {
49470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49471 }
49472 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49473 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49474 if (!SWIG_IsOK(res2)) {
49475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49476 }
49477 {
49478 PyThreadState* __tstate = wxPyBeginAllowThreads();
49479 (arg1)->SetSizer(arg2);
49480 wxPyEndAllowThreads(__tstate);
49481 if (PyErr_Occurred()) SWIG_fail;
49482 }
49483 resultobj = SWIG_Py_Void();
49484 return resultobj;
49485 fail:
49486 return NULL;
49487 }
49488
49489
49490 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49491 PyObject *resultobj = 0;
49492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49493 wxSize result;
49494 void *argp1 = 0 ;
49495 int res1 = 0 ;
49496 PyObject *swig_obj[1] ;
49497
49498 if (!args) SWIG_fail;
49499 swig_obj[0] = args;
49500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49501 if (!SWIG_IsOK(res1)) {
49502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49503 }
49504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49505 {
49506 PyThreadState* __tstate = wxPyBeginAllowThreads();
49507 result = (arg1)->GetSpacer();
49508 wxPyEndAllowThreads(__tstate);
49509 if (PyErr_Occurred()) SWIG_fail;
49510 }
49511 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49512 return resultobj;
49513 fail:
49514 return NULL;
49515 }
49516
49517
49518 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49519 PyObject *resultobj = 0;
49520 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49521 wxSize *arg2 = 0 ;
49522 void *argp1 = 0 ;
49523 int res1 = 0 ;
49524 wxSize temp2 ;
49525 PyObject * obj0 = 0 ;
49526 PyObject * obj1 = 0 ;
49527 char * kwnames[] = {
49528 (char *) "self",(char *) "size", NULL
49529 };
49530
49531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49533 if (!SWIG_IsOK(res1)) {
49534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49535 }
49536 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49537 {
49538 arg2 = &temp2;
49539 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49540 }
49541 {
49542 PyThreadState* __tstate = wxPyBeginAllowThreads();
49543 (arg1)->SetSpacer((wxSize const &)*arg2);
49544 wxPyEndAllowThreads(__tstate);
49545 if (PyErr_Occurred()) SWIG_fail;
49546 }
49547 resultobj = SWIG_Py_Void();
49548 return resultobj;
49549 fail:
49550 return NULL;
49551 }
49552
49553
49554 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49555 PyObject *resultobj = 0;
49556 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49557 bool arg2 ;
49558 void *argp1 = 0 ;
49559 int res1 = 0 ;
49560 bool val2 ;
49561 int ecode2 = 0 ;
49562 PyObject * obj0 = 0 ;
49563 PyObject * obj1 = 0 ;
49564 char * kwnames[] = {
49565 (char *) "self",(char *) "show", NULL
49566 };
49567
49568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49570 if (!SWIG_IsOK(res1)) {
49571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49572 }
49573 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49575 if (!SWIG_IsOK(ecode2)) {
49576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49577 }
49578 arg2 = static_cast< bool >(val2);
49579 {
49580 PyThreadState* __tstate = wxPyBeginAllowThreads();
49581 (arg1)->Show(arg2);
49582 wxPyEndAllowThreads(__tstate);
49583 if (PyErr_Occurred()) SWIG_fail;
49584 }
49585 resultobj = SWIG_Py_Void();
49586 return resultobj;
49587 fail:
49588 return NULL;
49589 }
49590
49591
49592 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49593 PyObject *resultobj = 0;
49594 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49595 bool result;
49596 void *argp1 = 0 ;
49597 int res1 = 0 ;
49598 PyObject *swig_obj[1] ;
49599
49600 if (!args) SWIG_fail;
49601 swig_obj[0] = args;
49602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49603 if (!SWIG_IsOK(res1)) {
49604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49605 }
49606 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49607 {
49608 PyThreadState* __tstate = wxPyBeginAllowThreads();
49609 result = (bool)(arg1)->IsShown();
49610 wxPyEndAllowThreads(__tstate);
49611 if (PyErr_Occurred()) SWIG_fail;
49612 }
49613 {
49614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49615 }
49616 return resultobj;
49617 fail:
49618 return NULL;
49619 }
49620
49621
49622 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49623 PyObject *resultobj = 0;
49624 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49625 wxPoint result;
49626 void *argp1 = 0 ;
49627 int res1 = 0 ;
49628 PyObject *swig_obj[1] ;
49629
49630 if (!args) SWIG_fail;
49631 swig_obj[0] = args;
49632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49633 if (!SWIG_IsOK(res1)) {
49634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49635 }
49636 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49637 {
49638 PyThreadState* __tstate = wxPyBeginAllowThreads();
49639 result = (arg1)->GetPosition();
49640 wxPyEndAllowThreads(__tstate);
49641 if (PyErr_Occurred()) SWIG_fail;
49642 }
49643 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49644 return resultobj;
49645 fail:
49646 return NULL;
49647 }
49648
49649
49650 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49651 PyObject *resultobj = 0;
49652 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49653 PyObject *result = 0 ;
49654 void *argp1 = 0 ;
49655 int res1 = 0 ;
49656 PyObject *swig_obj[1] ;
49657
49658 if (!args) SWIG_fail;
49659 swig_obj[0] = args;
49660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49661 if (!SWIG_IsOK(res1)) {
49662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49663 }
49664 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49665 {
49666 PyThreadState* __tstate = wxPyBeginAllowThreads();
49667 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49668 wxPyEndAllowThreads(__tstate);
49669 if (PyErr_Occurred()) SWIG_fail;
49670 }
49671 resultobj = result;
49672 return resultobj;
49673 fail:
49674 return NULL;
49675 }
49676
49677
49678 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49679 PyObject *resultobj = 0;
49680 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49681 PyObject *arg2 = (PyObject *) 0 ;
49682 void *argp1 = 0 ;
49683 int res1 = 0 ;
49684 PyObject * obj0 = 0 ;
49685 PyObject * obj1 = 0 ;
49686 char * kwnames[] = {
49687 (char *) "self",(char *) "userData", NULL
49688 };
49689
49690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49692 if (!SWIG_IsOK(res1)) {
49693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49694 }
49695 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49696 arg2 = obj1;
49697 {
49698 PyThreadState* __tstate = wxPyBeginAllowThreads();
49699 wxSizerItem_SetUserData(arg1,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 *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49711 PyObject *obj;
49712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49713 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49714 return SWIG_Py_Void();
49715 }
49716
49717 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49718 return SWIG_Python_InitShadowInstance(args);
49719 }
49720
49721 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49722 PyObject *resultobj = 0;
49723 wxSizer *arg1 = (wxSizer *) 0 ;
49724 void *argp1 = 0 ;
49725 int res1 = 0 ;
49726 PyObject *swig_obj[1] ;
49727
49728 if (!args) SWIG_fail;
49729 swig_obj[0] = args;
49730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49731 if (!SWIG_IsOK(res1)) {
49732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49733 }
49734 arg1 = reinterpret_cast< wxSizer * >(argp1);
49735 {
49736 PyThreadState* __tstate = wxPyBeginAllowThreads();
49737 delete arg1;
49738
49739 wxPyEndAllowThreads(__tstate);
49740 if (PyErr_Occurred()) SWIG_fail;
49741 }
49742 resultobj = SWIG_Py_Void();
49743 return resultobj;
49744 fail:
49745 return NULL;
49746 }
49747
49748
49749 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49750 PyObject *resultobj = 0;
49751 wxSizer *arg1 = (wxSizer *) 0 ;
49752 PyObject *arg2 = (PyObject *) 0 ;
49753 void *argp1 = 0 ;
49754 int res1 = 0 ;
49755 PyObject * obj0 = 0 ;
49756 PyObject * obj1 = 0 ;
49757 char * kwnames[] = {
49758 (char *) "self",(char *) "_self", NULL
49759 };
49760
49761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49763 if (!SWIG_IsOK(res1)) {
49764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49765 }
49766 arg1 = reinterpret_cast< wxSizer * >(argp1);
49767 arg2 = obj1;
49768 {
49769 PyThreadState* __tstate = wxPyBeginAllowThreads();
49770 wxSizer__setOORInfo(arg1,arg2);
49771 wxPyEndAllowThreads(__tstate);
49772 if (PyErr_Occurred()) SWIG_fail;
49773 }
49774 resultobj = SWIG_Py_Void();
49775 return resultobj;
49776 fail:
49777 return NULL;
49778 }
49779
49780
49781 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49782 PyObject *resultobj = 0;
49783 wxSizer *arg1 = (wxSizer *) 0 ;
49784 PyObject *arg2 = (PyObject *) 0 ;
49785 int arg3 = (int) 0 ;
49786 int arg4 = (int) 0 ;
49787 int arg5 = (int) 0 ;
49788 PyObject *arg6 = (PyObject *) NULL ;
49789 wxSizerItem *result = 0 ;
49790 void *argp1 = 0 ;
49791 int res1 = 0 ;
49792 int val3 ;
49793 int ecode3 = 0 ;
49794 int val4 ;
49795 int ecode4 = 0 ;
49796 int val5 ;
49797 int ecode5 = 0 ;
49798 PyObject * obj0 = 0 ;
49799 PyObject * obj1 = 0 ;
49800 PyObject * obj2 = 0 ;
49801 PyObject * obj3 = 0 ;
49802 PyObject * obj4 = 0 ;
49803 PyObject * obj5 = 0 ;
49804 char * kwnames[] = {
49805 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49806 };
49807
49808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49810 if (!SWIG_IsOK(res1)) {
49811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49812 }
49813 arg1 = reinterpret_cast< wxSizer * >(argp1);
49814 arg2 = obj1;
49815 if (obj2) {
49816 ecode3 = SWIG_AsVal_int(obj2, &val3);
49817 if (!SWIG_IsOK(ecode3)) {
49818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49819 }
49820 arg3 = static_cast< int >(val3);
49821 }
49822 if (obj3) {
49823 ecode4 = SWIG_AsVal_int(obj3, &val4);
49824 if (!SWIG_IsOK(ecode4)) {
49825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49826 }
49827 arg4 = static_cast< int >(val4);
49828 }
49829 if (obj4) {
49830 ecode5 = SWIG_AsVal_int(obj4, &val5);
49831 if (!SWIG_IsOK(ecode5)) {
49832 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49833 }
49834 arg5 = static_cast< int >(val5);
49835 }
49836 if (obj5) {
49837 arg6 = obj5;
49838 }
49839 {
49840 PyThreadState* __tstate = wxPyBeginAllowThreads();
49841 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49842 wxPyEndAllowThreads(__tstate);
49843 if (PyErr_Occurred()) SWIG_fail;
49844 }
49845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49846 return resultobj;
49847 fail:
49848 return NULL;
49849 }
49850
49851
49852 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49853 PyObject *resultobj = 0;
49854 wxSizer *arg1 = (wxSizer *) 0 ;
49855 int arg2 ;
49856 PyObject *arg3 = (PyObject *) 0 ;
49857 int arg4 = (int) 0 ;
49858 int arg5 = (int) 0 ;
49859 int arg6 = (int) 0 ;
49860 PyObject *arg7 = (PyObject *) NULL ;
49861 wxSizerItem *result = 0 ;
49862 void *argp1 = 0 ;
49863 int res1 = 0 ;
49864 int val2 ;
49865 int ecode2 = 0 ;
49866 int val4 ;
49867 int ecode4 = 0 ;
49868 int val5 ;
49869 int ecode5 = 0 ;
49870 int val6 ;
49871 int ecode6 = 0 ;
49872 PyObject * obj0 = 0 ;
49873 PyObject * obj1 = 0 ;
49874 PyObject * obj2 = 0 ;
49875 PyObject * obj3 = 0 ;
49876 PyObject * obj4 = 0 ;
49877 PyObject * obj5 = 0 ;
49878 PyObject * obj6 = 0 ;
49879 char * kwnames[] = {
49880 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49881 };
49882
49883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49885 if (!SWIG_IsOK(res1)) {
49886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49887 }
49888 arg1 = reinterpret_cast< wxSizer * >(argp1);
49889 ecode2 = SWIG_AsVal_int(obj1, &val2);
49890 if (!SWIG_IsOK(ecode2)) {
49891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49892 }
49893 arg2 = static_cast< int >(val2);
49894 arg3 = obj2;
49895 if (obj3) {
49896 ecode4 = SWIG_AsVal_int(obj3, &val4);
49897 if (!SWIG_IsOK(ecode4)) {
49898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49899 }
49900 arg4 = static_cast< int >(val4);
49901 }
49902 if (obj4) {
49903 ecode5 = SWIG_AsVal_int(obj4, &val5);
49904 if (!SWIG_IsOK(ecode5)) {
49905 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49906 }
49907 arg5 = static_cast< int >(val5);
49908 }
49909 if (obj5) {
49910 ecode6 = SWIG_AsVal_int(obj5, &val6);
49911 if (!SWIG_IsOK(ecode6)) {
49912 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49913 }
49914 arg6 = static_cast< int >(val6);
49915 }
49916 if (obj6) {
49917 arg7 = obj6;
49918 }
49919 {
49920 PyThreadState* __tstate = wxPyBeginAllowThreads();
49921 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49922 wxPyEndAllowThreads(__tstate);
49923 if (PyErr_Occurred()) SWIG_fail;
49924 }
49925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49926 return resultobj;
49927 fail:
49928 return NULL;
49929 }
49930
49931
49932 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49933 PyObject *resultobj = 0;
49934 wxSizer *arg1 = (wxSizer *) 0 ;
49935 PyObject *arg2 = (PyObject *) 0 ;
49936 int arg3 = (int) 0 ;
49937 int arg4 = (int) 0 ;
49938 int arg5 = (int) 0 ;
49939 PyObject *arg6 = (PyObject *) NULL ;
49940 wxSizerItem *result = 0 ;
49941 void *argp1 = 0 ;
49942 int res1 = 0 ;
49943 int val3 ;
49944 int ecode3 = 0 ;
49945 int val4 ;
49946 int ecode4 = 0 ;
49947 int val5 ;
49948 int ecode5 = 0 ;
49949 PyObject * obj0 = 0 ;
49950 PyObject * obj1 = 0 ;
49951 PyObject * obj2 = 0 ;
49952 PyObject * obj3 = 0 ;
49953 PyObject * obj4 = 0 ;
49954 PyObject * obj5 = 0 ;
49955 char * kwnames[] = {
49956 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49957 };
49958
49959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49961 if (!SWIG_IsOK(res1)) {
49962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49963 }
49964 arg1 = reinterpret_cast< wxSizer * >(argp1);
49965 arg2 = obj1;
49966 if (obj2) {
49967 ecode3 = SWIG_AsVal_int(obj2, &val3);
49968 if (!SWIG_IsOK(ecode3)) {
49969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49970 }
49971 arg3 = static_cast< int >(val3);
49972 }
49973 if (obj3) {
49974 ecode4 = SWIG_AsVal_int(obj3, &val4);
49975 if (!SWIG_IsOK(ecode4)) {
49976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49977 }
49978 arg4 = static_cast< int >(val4);
49979 }
49980 if (obj4) {
49981 ecode5 = SWIG_AsVal_int(obj4, &val5);
49982 if (!SWIG_IsOK(ecode5)) {
49983 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49984 }
49985 arg5 = static_cast< int >(val5);
49986 }
49987 if (obj5) {
49988 arg6 = obj5;
49989 }
49990 {
49991 PyThreadState* __tstate = wxPyBeginAllowThreads();
49992 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49993 wxPyEndAllowThreads(__tstate);
49994 if (PyErr_Occurred()) SWIG_fail;
49995 }
49996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49997 return resultobj;
49998 fail:
49999 return NULL;
50000 }
50001
50002
50003 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50004 PyObject *resultobj = 0;
50005 wxSizer *arg1 = (wxSizer *) 0 ;
50006 PyObject *arg2 = (PyObject *) 0 ;
50007 bool result;
50008 void *argp1 = 0 ;
50009 int res1 = 0 ;
50010 PyObject * obj0 = 0 ;
50011 PyObject * obj1 = 0 ;
50012 char * kwnames[] = {
50013 (char *) "self",(char *) "item", NULL
50014 };
50015
50016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50018 if (!SWIG_IsOK(res1)) {
50019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50020 }
50021 arg1 = reinterpret_cast< wxSizer * >(argp1);
50022 arg2 = obj1;
50023 {
50024 PyThreadState* __tstate = wxPyBeginAllowThreads();
50025 result = (bool)wxSizer_Remove(arg1,arg2);
50026 wxPyEndAllowThreads(__tstate);
50027 if (PyErr_Occurred()) SWIG_fail;
50028 }
50029 {
50030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50031 }
50032 return resultobj;
50033 fail:
50034 return NULL;
50035 }
50036
50037
50038 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50039 PyObject *resultobj = 0;
50040 wxSizer *arg1 = (wxSizer *) 0 ;
50041 PyObject *arg2 = (PyObject *) 0 ;
50042 bool result;
50043 void *argp1 = 0 ;
50044 int res1 = 0 ;
50045 PyObject * obj0 = 0 ;
50046 PyObject * obj1 = 0 ;
50047 char * kwnames[] = {
50048 (char *) "self",(char *) "item", NULL
50049 };
50050
50051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50053 if (!SWIG_IsOK(res1)) {
50054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50055 }
50056 arg1 = reinterpret_cast< wxSizer * >(argp1);
50057 arg2 = obj1;
50058 {
50059 PyThreadState* __tstate = wxPyBeginAllowThreads();
50060 result = (bool)wxSizer_Detach(arg1,arg2);
50061 wxPyEndAllowThreads(__tstate);
50062 if (PyErr_Occurred()) SWIG_fail;
50063 }
50064 {
50065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50066 }
50067 return resultobj;
50068 fail:
50069 return NULL;
50070 }
50071
50072
50073 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50074 PyObject *resultobj = 0;
50075 wxSizer *arg1 = (wxSizer *) 0 ;
50076 PyObject *arg2 = (PyObject *) 0 ;
50077 wxSizerItem *result = 0 ;
50078 void *argp1 = 0 ;
50079 int res1 = 0 ;
50080 PyObject * obj0 = 0 ;
50081 PyObject * obj1 = 0 ;
50082 char * kwnames[] = {
50083 (char *) "self",(char *) "item", NULL
50084 };
50085
50086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50088 if (!SWIG_IsOK(res1)) {
50089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50090 }
50091 arg1 = reinterpret_cast< wxSizer * >(argp1);
50092 arg2 = obj1;
50093 {
50094 PyThreadState* __tstate = wxPyBeginAllowThreads();
50095 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50096 wxPyEndAllowThreads(__tstate);
50097 if (PyErr_Occurred()) SWIG_fail;
50098 }
50099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50100 return resultobj;
50101 fail:
50102 return NULL;
50103 }
50104
50105
50106 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50107 PyObject *resultobj = 0;
50108 wxSizer *arg1 = (wxSizer *) 0 ;
50109 PyObject *arg2 = (PyObject *) 0 ;
50110 wxSize *arg3 = 0 ;
50111 void *argp1 = 0 ;
50112 int res1 = 0 ;
50113 wxSize temp3 ;
50114 PyObject * obj0 = 0 ;
50115 PyObject * obj1 = 0 ;
50116 PyObject * obj2 = 0 ;
50117 char * kwnames[] = {
50118 (char *) "self",(char *) "item",(char *) "size", NULL
50119 };
50120
50121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50123 if (!SWIG_IsOK(res1)) {
50124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50125 }
50126 arg1 = reinterpret_cast< wxSizer * >(argp1);
50127 arg2 = obj1;
50128 {
50129 arg3 = &temp3;
50130 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50131 }
50132 {
50133 PyThreadState* __tstate = wxPyBeginAllowThreads();
50134 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50135 wxPyEndAllowThreads(__tstate);
50136 if (PyErr_Occurred()) SWIG_fail;
50137 }
50138 resultobj = SWIG_Py_Void();
50139 return resultobj;
50140 fail:
50141 return NULL;
50142 }
50143
50144
50145 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50146 PyObject *resultobj = 0;
50147 wxSizer *arg1 = (wxSizer *) 0 ;
50148 wxWindow *arg2 = (wxWindow *) 0 ;
50149 wxWindow *arg3 = (wxWindow *) 0 ;
50150 bool arg4 = (bool) false ;
50151 bool result;
50152 void *argp1 = 0 ;
50153 int res1 = 0 ;
50154 void *argp2 = 0 ;
50155 int res2 = 0 ;
50156 void *argp3 = 0 ;
50157 int res3 = 0 ;
50158 bool val4 ;
50159 int ecode4 = 0 ;
50160 PyObject * obj0 = 0 ;
50161 PyObject * obj1 = 0 ;
50162 PyObject * obj2 = 0 ;
50163 PyObject * obj3 = 0 ;
50164 char * kwnames[] = {
50165 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50166 };
50167
50168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50170 if (!SWIG_IsOK(res1)) {
50171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50172 }
50173 arg1 = reinterpret_cast< wxSizer * >(argp1);
50174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50175 if (!SWIG_IsOK(res2)) {
50176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50177 }
50178 arg2 = reinterpret_cast< wxWindow * >(argp2);
50179 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50180 if (!SWIG_IsOK(res3)) {
50181 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50182 }
50183 arg3 = reinterpret_cast< wxWindow * >(argp3);
50184 if (obj3) {
50185 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50186 if (!SWIG_IsOK(ecode4)) {
50187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50188 }
50189 arg4 = static_cast< bool >(val4);
50190 }
50191 {
50192 PyThreadState* __tstate = wxPyBeginAllowThreads();
50193 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50194 wxPyEndAllowThreads(__tstate);
50195 if (PyErr_Occurred()) SWIG_fail;
50196 }
50197 {
50198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50199 }
50200 return resultobj;
50201 fail:
50202 return NULL;
50203 }
50204
50205
50206 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50207 PyObject *resultobj = 0;
50208 wxSizer *arg1 = (wxSizer *) 0 ;
50209 wxSizer *arg2 = (wxSizer *) 0 ;
50210 wxSizer *arg3 = (wxSizer *) 0 ;
50211 bool arg4 = (bool) false ;
50212 bool result;
50213 void *argp1 = 0 ;
50214 int res1 = 0 ;
50215 void *argp2 = 0 ;
50216 int res2 = 0 ;
50217 void *argp3 = 0 ;
50218 int res3 = 0 ;
50219 bool val4 ;
50220 int ecode4 = 0 ;
50221 PyObject * obj0 = 0 ;
50222 PyObject * obj1 = 0 ;
50223 PyObject * obj2 = 0 ;
50224 PyObject * obj3 = 0 ;
50225 char * kwnames[] = {
50226 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50227 };
50228
50229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50231 if (!SWIG_IsOK(res1)) {
50232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50233 }
50234 arg1 = reinterpret_cast< wxSizer * >(argp1);
50235 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50236 if (!SWIG_IsOK(res2)) {
50237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50238 }
50239 arg2 = reinterpret_cast< wxSizer * >(argp2);
50240 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50241 if (!SWIG_IsOK(res3)) {
50242 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50243 }
50244 arg3 = reinterpret_cast< wxSizer * >(argp3);
50245 if (obj3) {
50246 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50247 if (!SWIG_IsOK(ecode4)) {
50248 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50249 }
50250 arg4 = static_cast< bool >(val4);
50251 }
50252 {
50253 PyThreadState* __tstate = wxPyBeginAllowThreads();
50254 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50255 wxPyEndAllowThreads(__tstate);
50256 if (PyErr_Occurred()) SWIG_fail;
50257 }
50258 {
50259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50260 }
50261 return resultobj;
50262 fail:
50263 return NULL;
50264 }
50265
50266
50267 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50268 PyObject *resultobj = 0;
50269 wxSizer *arg1 = (wxSizer *) 0 ;
50270 size_t arg2 ;
50271 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50272 bool result;
50273 void *argp1 = 0 ;
50274 int res1 = 0 ;
50275 size_t val2 ;
50276 int ecode2 = 0 ;
50277 void *argp3 = 0 ;
50278 int res3 = 0 ;
50279 PyObject * obj0 = 0 ;
50280 PyObject * obj1 = 0 ;
50281 PyObject * obj2 = 0 ;
50282 char * kwnames[] = {
50283 (char *) "self",(char *) "index",(char *) "newitem", NULL
50284 };
50285
50286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50288 if (!SWIG_IsOK(res1)) {
50289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50290 }
50291 arg1 = reinterpret_cast< wxSizer * >(argp1);
50292 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50293 if (!SWIG_IsOK(ecode2)) {
50294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50295 }
50296 arg2 = static_cast< size_t >(val2);
50297 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50298 if (!SWIG_IsOK(res3)) {
50299 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50300 }
50301 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50302 {
50303 PyThreadState* __tstate = wxPyBeginAllowThreads();
50304 result = (bool)(arg1)->Replace(arg2,arg3);
50305 wxPyEndAllowThreads(__tstate);
50306 if (PyErr_Occurred()) SWIG_fail;
50307 }
50308 {
50309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50310 }
50311 return resultobj;
50312 fail:
50313 return NULL;
50314 }
50315
50316
50317 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50318 PyObject *resultobj = 0;
50319 wxSizer *arg1 = (wxSizer *) 0 ;
50320 wxWindow *arg2 = (wxWindow *) 0 ;
50321 void *argp1 = 0 ;
50322 int res1 = 0 ;
50323 void *argp2 = 0 ;
50324 int res2 = 0 ;
50325 PyObject * obj0 = 0 ;
50326 PyObject * obj1 = 0 ;
50327 char * kwnames[] = {
50328 (char *) "self",(char *) "window", NULL
50329 };
50330
50331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50333 if (!SWIG_IsOK(res1)) {
50334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50335 }
50336 arg1 = reinterpret_cast< wxSizer * >(argp1);
50337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50338 if (!SWIG_IsOK(res2)) {
50339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50340 }
50341 arg2 = reinterpret_cast< wxWindow * >(argp2);
50342 {
50343 PyThreadState* __tstate = wxPyBeginAllowThreads();
50344 (arg1)->SetContainingWindow(arg2);
50345 wxPyEndAllowThreads(__tstate);
50346 if (PyErr_Occurred()) SWIG_fail;
50347 }
50348 resultobj = SWIG_Py_Void();
50349 return resultobj;
50350 fail:
50351 return NULL;
50352 }
50353
50354
50355 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50356 PyObject *resultobj = 0;
50357 wxSizer *arg1 = (wxSizer *) 0 ;
50358 wxWindow *result = 0 ;
50359 void *argp1 = 0 ;
50360 int res1 = 0 ;
50361 PyObject *swig_obj[1] ;
50362
50363 if (!args) SWIG_fail;
50364 swig_obj[0] = args;
50365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50366 if (!SWIG_IsOK(res1)) {
50367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50368 }
50369 arg1 = reinterpret_cast< wxSizer * >(argp1);
50370 {
50371 PyThreadState* __tstate = wxPyBeginAllowThreads();
50372 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50373 wxPyEndAllowThreads(__tstate);
50374 if (PyErr_Occurred()) SWIG_fail;
50375 }
50376 {
50377 resultobj = wxPyMake_wxObject(result, 0);
50378 }
50379 return resultobj;
50380 fail:
50381 return NULL;
50382 }
50383
50384
50385 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50386 PyObject *resultobj = 0;
50387 wxSizer *arg1 = (wxSizer *) 0 ;
50388 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50389 wxSizerItem *result = 0 ;
50390 void *argp1 = 0 ;
50391 int res1 = 0 ;
50392 int res2 = 0 ;
50393 PyObject * obj0 = 0 ;
50394 PyObject * obj1 = 0 ;
50395 char * kwnames[] = {
50396 (char *) "self",(char *) "item", NULL
50397 };
50398
50399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50401 if (!SWIG_IsOK(res1)) {
50402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50403 }
50404 arg1 = reinterpret_cast< wxSizer * >(argp1);
50405 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50406 if (!SWIG_IsOK(res2)) {
50407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50408 }
50409 {
50410 PyThreadState* __tstate = wxPyBeginAllowThreads();
50411 result = (wxSizerItem *)(arg1)->Add(arg2);
50412 wxPyEndAllowThreads(__tstate);
50413 if (PyErr_Occurred()) SWIG_fail;
50414 }
50415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50416 return resultobj;
50417 fail:
50418 return NULL;
50419 }
50420
50421
50422 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50423 PyObject *resultobj = 0;
50424 wxSizer *arg1 = (wxSizer *) 0 ;
50425 size_t arg2 ;
50426 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50427 wxSizerItem *result = 0 ;
50428 void *argp1 = 0 ;
50429 int res1 = 0 ;
50430 size_t val2 ;
50431 int ecode2 = 0 ;
50432 int res3 = 0 ;
50433 PyObject * obj0 = 0 ;
50434 PyObject * obj1 = 0 ;
50435 PyObject * obj2 = 0 ;
50436 char * kwnames[] = {
50437 (char *) "self",(char *) "index",(char *) "item", NULL
50438 };
50439
50440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50442 if (!SWIG_IsOK(res1)) {
50443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50444 }
50445 arg1 = reinterpret_cast< wxSizer * >(argp1);
50446 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50447 if (!SWIG_IsOK(ecode2)) {
50448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50449 }
50450 arg2 = static_cast< size_t >(val2);
50451 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50452 if (!SWIG_IsOK(res3)) {
50453 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50454 }
50455 {
50456 PyThreadState* __tstate = wxPyBeginAllowThreads();
50457 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50458 wxPyEndAllowThreads(__tstate);
50459 if (PyErr_Occurred()) SWIG_fail;
50460 }
50461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50462 return resultobj;
50463 fail:
50464 return NULL;
50465 }
50466
50467
50468 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50469 PyObject *resultobj = 0;
50470 wxSizer *arg1 = (wxSizer *) 0 ;
50471 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50472 wxSizerItem *result = 0 ;
50473 void *argp1 = 0 ;
50474 int res1 = 0 ;
50475 int res2 = 0 ;
50476 PyObject * obj0 = 0 ;
50477 PyObject * obj1 = 0 ;
50478 char * kwnames[] = {
50479 (char *) "self",(char *) "item", NULL
50480 };
50481
50482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50484 if (!SWIG_IsOK(res1)) {
50485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50486 }
50487 arg1 = reinterpret_cast< wxSizer * >(argp1);
50488 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50489 if (!SWIG_IsOK(res2)) {
50490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50491 }
50492 {
50493 PyThreadState* __tstate = wxPyBeginAllowThreads();
50494 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50495 wxPyEndAllowThreads(__tstate);
50496 if (PyErr_Occurred()) SWIG_fail;
50497 }
50498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50499 return resultobj;
50500 fail:
50501 return NULL;
50502 }
50503
50504
50505 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50506 PyObject *resultobj = 0;
50507 wxSizer *arg1 = (wxSizer *) 0 ;
50508 int arg2 ;
50509 int arg3 ;
50510 int arg4 ;
50511 int arg5 ;
50512 void *argp1 = 0 ;
50513 int res1 = 0 ;
50514 int val2 ;
50515 int ecode2 = 0 ;
50516 int val3 ;
50517 int ecode3 = 0 ;
50518 int val4 ;
50519 int ecode4 = 0 ;
50520 int val5 ;
50521 int ecode5 = 0 ;
50522 PyObject * obj0 = 0 ;
50523 PyObject * obj1 = 0 ;
50524 PyObject * obj2 = 0 ;
50525 PyObject * obj3 = 0 ;
50526 PyObject * obj4 = 0 ;
50527 char * kwnames[] = {
50528 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50529 };
50530
50531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50533 if (!SWIG_IsOK(res1)) {
50534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50535 }
50536 arg1 = reinterpret_cast< wxSizer * >(argp1);
50537 ecode2 = SWIG_AsVal_int(obj1, &val2);
50538 if (!SWIG_IsOK(ecode2)) {
50539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50540 }
50541 arg2 = static_cast< int >(val2);
50542 ecode3 = SWIG_AsVal_int(obj2, &val3);
50543 if (!SWIG_IsOK(ecode3)) {
50544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50545 }
50546 arg3 = static_cast< int >(val3);
50547 ecode4 = SWIG_AsVal_int(obj3, &val4);
50548 if (!SWIG_IsOK(ecode4)) {
50549 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50550 }
50551 arg4 = static_cast< int >(val4);
50552 ecode5 = SWIG_AsVal_int(obj4, &val5);
50553 if (!SWIG_IsOK(ecode5)) {
50554 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50555 }
50556 arg5 = static_cast< int >(val5);
50557 {
50558 PyThreadState* __tstate = wxPyBeginAllowThreads();
50559 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50560 wxPyEndAllowThreads(__tstate);
50561 if (PyErr_Occurred()) SWIG_fail;
50562 }
50563 resultobj = SWIG_Py_Void();
50564 return resultobj;
50565 fail:
50566 return NULL;
50567 }
50568
50569
50570 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50571 PyObject *resultobj = 0;
50572 wxSizer *arg1 = (wxSizer *) 0 ;
50573 wxSize *arg2 = 0 ;
50574 void *argp1 = 0 ;
50575 int res1 = 0 ;
50576 wxSize temp2 ;
50577 PyObject * obj0 = 0 ;
50578 PyObject * obj1 = 0 ;
50579 char * kwnames[] = {
50580 (char *) "self",(char *) "size", NULL
50581 };
50582
50583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50585 if (!SWIG_IsOK(res1)) {
50586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50587 }
50588 arg1 = reinterpret_cast< wxSizer * >(argp1);
50589 {
50590 arg2 = &temp2;
50591 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50592 }
50593 {
50594 PyThreadState* __tstate = wxPyBeginAllowThreads();
50595 (arg1)->SetMinSize((wxSize const &)*arg2);
50596 wxPyEndAllowThreads(__tstate);
50597 if (PyErr_Occurred()) SWIG_fail;
50598 }
50599 resultobj = SWIG_Py_Void();
50600 return resultobj;
50601 fail:
50602 return NULL;
50603 }
50604
50605
50606 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50607 PyObject *resultobj = 0;
50608 wxSizer *arg1 = (wxSizer *) 0 ;
50609 wxSize result;
50610 void *argp1 = 0 ;
50611 int res1 = 0 ;
50612 PyObject *swig_obj[1] ;
50613
50614 if (!args) SWIG_fail;
50615 swig_obj[0] = args;
50616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50617 if (!SWIG_IsOK(res1)) {
50618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50619 }
50620 arg1 = reinterpret_cast< wxSizer * >(argp1);
50621 {
50622 PyThreadState* __tstate = wxPyBeginAllowThreads();
50623 result = (arg1)->GetSize();
50624 wxPyEndAllowThreads(__tstate);
50625 if (PyErr_Occurred()) SWIG_fail;
50626 }
50627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50628 return resultobj;
50629 fail:
50630 return NULL;
50631 }
50632
50633
50634 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50635 PyObject *resultobj = 0;
50636 wxSizer *arg1 = (wxSizer *) 0 ;
50637 wxPoint result;
50638 void *argp1 = 0 ;
50639 int res1 = 0 ;
50640 PyObject *swig_obj[1] ;
50641
50642 if (!args) SWIG_fail;
50643 swig_obj[0] = args;
50644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50645 if (!SWIG_IsOK(res1)) {
50646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50647 }
50648 arg1 = reinterpret_cast< wxSizer * >(argp1);
50649 {
50650 PyThreadState* __tstate = wxPyBeginAllowThreads();
50651 result = (arg1)->GetPosition();
50652 wxPyEndAllowThreads(__tstate);
50653 if (PyErr_Occurred()) SWIG_fail;
50654 }
50655 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50656 return resultobj;
50657 fail:
50658 return NULL;
50659 }
50660
50661
50662 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50663 PyObject *resultobj = 0;
50664 wxSizer *arg1 = (wxSizer *) 0 ;
50665 wxSize result;
50666 void *argp1 = 0 ;
50667 int res1 = 0 ;
50668 PyObject *swig_obj[1] ;
50669
50670 if (!args) SWIG_fail;
50671 swig_obj[0] = args;
50672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50673 if (!SWIG_IsOK(res1)) {
50674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50675 }
50676 arg1 = reinterpret_cast< wxSizer * >(argp1);
50677 {
50678 PyThreadState* __tstate = wxPyBeginAllowThreads();
50679 result = (arg1)->GetMinSize();
50680 wxPyEndAllowThreads(__tstate);
50681 if (PyErr_Occurred()) SWIG_fail;
50682 }
50683 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50684 return resultobj;
50685 fail:
50686 return NULL;
50687 }
50688
50689
50690 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50691 PyObject *resultobj = 0;
50692 wxSizer *arg1 = (wxSizer *) 0 ;
50693 void *argp1 = 0 ;
50694 int res1 = 0 ;
50695 PyObject *swig_obj[1] ;
50696
50697 if (!args) SWIG_fail;
50698 swig_obj[0] = args;
50699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50700 if (!SWIG_IsOK(res1)) {
50701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50702 }
50703 arg1 = reinterpret_cast< wxSizer * >(argp1);
50704 {
50705 PyThreadState* __tstate = wxPyBeginAllowThreads();
50706 (arg1)->RecalcSizes();
50707 wxPyEndAllowThreads(__tstate);
50708 if (PyErr_Occurred()) SWIG_fail;
50709 }
50710 resultobj = SWIG_Py_Void();
50711 return resultobj;
50712 fail:
50713 return NULL;
50714 }
50715
50716
50717 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50718 PyObject *resultobj = 0;
50719 wxSizer *arg1 = (wxSizer *) 0 ;
50720 wxSize result;
50721 void *argp1 = 0 ;
50722 int res1 = 0 ;
50723 PyObject *swig_obj[1] ;
50724
50725 if (!args) SWIG_fail;
50726 swig_obj[0] = args;
50727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50728 if (!SWIG_IsOK(res1)) {
50729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50730 }
50731 arg1 = reinterpret_cast< wxSizer * >(argp1);
50732 {
50733 PyThreadState* __tstate = wxPyBeginAllowThreads();
50734 result = (arg1)->CalcMin();
50735 wxPyEndAllowThreads(__tstate);
50736 if (PyErr_Occurred()) SWIG_fail;
50737 }
50738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50739 return resultobj;
50740 fail:
50741 return NULL;
50742 }
50743
50744
50745 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50746 PyObject *resultobj = 0;
50747 wxSizer *arg1 = (wxSizer *) 0 ;
50748 void *argp1 = 0 ;
50749 int res1 = 0 ;
50750 PyObject *swig_obj[1] ;
50751
50752 if (!args) SWIG_fail;
50753 swig_obj[0] = args;
50754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50755 if (!SWIG_IsOK(res1)) {
50756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50757 }
50758 arg1 = reinterpret_cast< wxSizer * >(argp1);
50759 {
50760 PyThreadState* __tstate = wxPyBeginAllowThreads();
50761 (arg1)->Layout();
50762 wxPyEndAllowThreads(__tstate);
50763 if (PyErr_Occurred()) SWIG_fail;
50764 }
50765 resultobj = SWIG_Py_Void();
50766 return resultobj;
50767 fail:
50768 return NULL;
50769 }
50770
50771
50772 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50773 PyObject *resultobj = 0;
50774 wxSizer *arg1 = (wxSizer *) 0 ;
50775 wxWindow *arg2 = (wxWindow *) 0 ;
50776 wxSize result;
50777 void *argp1 = 0 ;
50778 int res1 = 0 ;
50779 void *argp2 = 0 ;
50780 int res2 = 0 ;
50781 PyObject * obj0 = 0 ;
50782 PyObject * obj1 = 0 ;
50783 char * kwnames[] = {
50784 (char *) "self",(char *) "window", NULL
50785 };
50786
50787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50789 if (!SWIG_IsOK(res1)) {
50790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50791 }
50792 arg1 = reinterpret_cast< wxSizer * >(argp1);
50793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50794 if (!SWIG_IsOK(res2)) {
50795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50796 }
50797 arg2 = reinterpret_cast< wxWindow * >(argp2);
50798 {
50799 PyThreadState* __tstate = wxPyBeginAllowThreads();
50800 result = (arg1)->Fit(arg2);
50801 wxPyEndAllowThreads(__tstate);
50802 if (PyErr_Occurred()) SWIG_fail;
50803 }
50804 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50805 return resultobj;
50806 fail:
50807 return NULL;
50808 }
50809
50810
50811 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50812 PyObject *resultobj = 0;
50813 wxSizer *arg1 = (wxSizer *) 0 ;
50814 wxWindow *arg2 = (wxWindow *) 0 ;
50815 void *argp1 = 0 ;
50816 int res1 = 0 ;
50817 void *argp2 = 0 ;
50818 int res2 = 0 ;
50819 PyObject * obj0 = 0 ;
50820 PyObject * obj1 = 0 ;
50821 char * kwnames[] = {
50822 (char *) "self",(char *) "window", NULL
50823 };
50824
50825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50827 if (!SWIG_IsOK(res1)) {
50828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50829 }
50830 arg1 = reinterpret_cast< wxSizer * >(argp1);
50831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50832 if (!SWIG_IsOK(res2)) {
50833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50834 }
50835 arg2 = reinterpret_cast< wxWindow * >(argp2);
50836 {
50837 PyThreadState* __tstate = wxPyBeginAllowThreads();
50838 (arg1)->FitInside(arg2);
50839 wxPyEndAllowThreads(__tstate);
50840 if (PyErr_Occurred()) SWIG_fail;
50841 }
50842 resultobj = SWIG_Py_Void();
50843 return resultobj;
50844 fail:
50845 return NULL;
50846 }
50847
50848
50849 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50850 PyObject *resultobj = 0;
50851 wxSizer *arg1 = (wxSizer *) 0 ;
50852 wxWindow *arg2 = (wxWindow *) 0 ;
50853 void *argp1 = 0 ;
50854 int res1 = 0 ;
50855 void *argp2 = 0 ;
50856 int res2 = 0 ;
50857 PyObject * obj0 = 0 ;
50858 PyObject * obj1 = 0 ;
50859 char * kwnames[] = {
50860 (char *) "self",(char *) "window", NULL
50861 };
50862
50863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50865 if (!SWIG_IsOK(res1)) {
50866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50867 }
50868 arg1 = reinterpret_cast< wxSizer * >(argp1);
50869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50870 if (!SWIG_IsOK(res2)) {
50871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50872 }
50873 arg2 = reinterpret_cast< wxWindow * >(argp2);
50874 {
50875 PyThreadState* __tstate = wxPyBeginAllowThreads();
50876 (arg1)->SetSizeHints(arg2);
50877 wxPyEndAllowThreads(__tstate);
50878 if (PyErr_Occurred()) SWIG_fail;
50879 }
50880 resultobj = SWIG_Py_Void();
50881 return resultobj;
50882 fail:
50883 return NULL;
50884 }
50885
50886
50887 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50888 PyObject *resultobj = 0;
50889 wxSizer *arg1 = (wxSizer *) 0 ;
50890 wxWindow *arg2 = (wxWindow *) 0 ;
50891 void *argp1 = 0 ;
50892 int res1 = 0 ;
50893 void *argp2 = 0 ;
50894 int res2 = 0 ;
50895 PyObject * obj0 = 0 ;
50896 PyObject * obj1 = 0 ;
50897 char * kwnames[] = {
50898 (char *) "self",(char *) "window", NULL
50899 };
50900
50901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50903 if (!SWIG_IsOK(res1)) {
50904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50905 }
50906 arg1 = reinterpret_cast< wxSizer * >(argp1);
50907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50908 if (!SWIG_IsOK(res2)) {
50909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50910 }
50911 arg2 = reinterpret_cast< wxWindow * >(argp2);
50912 {
50913 PyThreadState* __tstate = wxPyBeginAllowThreads();
50914 (arg1)->SetVirtualSizeHints(arg2);
50915 wxPyEndAllowThreads(__tstate);
50916 if (PyErr_Occurred()) SWIG_fail;
50917 }
50918 resultobj = SWIG_Py_Void();
50919 return resultobj;
50920 fail:
50921 return NULL;
50922 }
50923
50924
50925 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50926 PyObject *resultobj = 0;
50927 wxSizer *arg1 = (wxSizer *) 0 ;
50928 bool arg2 = (bool) false ;
50929 void *argp1 = 0 ;
50930 int res1 = 0 ;
50931 bool val2 ;
50932 int ecode2 = 0 ;
50933 PyObject * obj0 = 0 ;
50934 PyObject * obj1 = 0 ;
50935 char * kwnames[] = {
50936 (char *) "self",(char *) "deleteWindows", NULL
50937 };
50938
50939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50941 if (!SWIG_IsOK(res1)) {
50942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50943 }
50944 arg1 = reinterpret_cast< wxSizer * >(argp1);
50945 if (obj1) {
50946 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50947 if (!SWIG_IsOK(ecode2)) {
50948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50949 }
50950 arg2 = static_cast< bool >(val2);
50951 }
50952 {
50953 PyThreadState* __tstate = wxPyBeginAllowThreads();
50954 (arg1)->Clear(arg2);
50955 wxPyEndAllowThreads(__tstate);
50956 if (PyErr_Occurred()) SWIG_fail;
50957 }
50958 resultobj = SWIG_Py_Void();
50959 return resultobj;
50960 fail:
50961 return NULL;
50962 }
50963
50964
50965 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50966 PyObject *resultobj = 0;
50967 wxSizer *arg1 = (wxSizer *) 0 ;
50968 void *argp1 = 0 ;
50969 int res1 = 0 ;
50970 PyObject *swig_obj[1] ;
50971
50972 if (!args) SWIG_fail;
50973 swig_obj[0] = args;
50974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50975 if (!SWIG_IsOK(res1)) {
50976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50977 }
50978 arg1 = reinterpret_cast< wxSizer * >(argp1);
50979 {
50980 PyThreadState* __tstate = wxPyBeginAllowThreads();
50981 (arg1)->DeleteWindows();
50982 wxPyEndAllowThreads(__tstate);
50983 if (PyErr_Occurred()) SWIG_fail;
50984 }
50985 resultobj = SWIG_Py_Void();
50986 return resultobj;
50987 fail:
50988 return NULL;
50989 }
50990
50991
50992 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50993 PyObject *resultobj = 0;
50994 wxSizer *arg1 = (wxSizer *) 0 ;
50995 PyObject *result = 0 ;
50996 void *argp1 = 0 ;
50997 int res1 = 0 ;
50998 PyObject *swig_obj[1] ;
50999
51000 if (!args) SWIG_fail;
51001 swig_obj[0] = args;
51002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51003 if (!SWIG_IsOK(res1)) {
51004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51005 }
51006 arg1 = reinterpret_cast< wxSizer * >(argp1);
51007 {
51008 PyThreadState* __tstate = wxPyBeginAllowThreads();
51009 result = (PyObject *)wxSizer_GetChildren(arg1);
51010 wxPyEndAllowThreads(__tstate);
51011 if (PyErr_Occurred()) SWIG_fail;
51012 }
51013 resultobj = result;
51014 return resultobj;
51015 fail:
51016 return NULL;
51017 }
51018
51019
51020 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51021 PyObject *resultobj = 0;
51022 wxSizer *arg1 = (wxSizer *) 0 ;
51023 PyObject *arg2 = (PyObject *) 0 ;
51024 bool arg3 = (bool) true ;
51025 bool arg4 = (bool) false ;
51026 bool result;
51027 void *argp1 = 0 ;
51028 int res1 = 0 ;
51029 bool val3 ;
51030 int ecode3 = 0 ;
51031 bool val4 ;
51032 int ecode4 = 0 ;
51033 PyObject * obj0 = 0 ;
51034 PyObject * obj1 = 0 ;
51035 PyObject * obj2 = 0 ;
51036 PyObject * obj3 = 0 ;
51037 char * kwnames[] = {
51038 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51039 };
51040
51041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51043 if (!SWIG_IsOK(res1)) {
51044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51045 }
51046 arg1 = reinterpret_cast< wxSizer * >(argp1);
51047 arg2 = obj1;
51048 if (obj2) {
51049 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51050 if (!SWIG_IsOK(ecode3)) {
51051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51052 }
51053 arg3 = static_cast< bool >(val3);
51054 }
51055 if (obj3) {
51056 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51057 if (!SWIG_IsOK(ecode4)) {
51058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51059 }
51060 arg4 = static_cast< bool >(val4);
51061 }
51062 {
51063 PyThreadState* __tstate = wxPyBeginAllowThreads();
51064 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51065 wxPyEndAllowThreads(__tstate);
51066 if (PyErr_Occurred()) SWIG_fail;
51067 }
51068 {
51069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51070 }
51071 return resultobj;
51072 fail:
51073 return NULL;
51074 }
51075
51076
51077 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51078 PyObject *resultobj = 0;
51079 wxSizer *arg1 = (wxSizer *) 0 ;
51080 PyObject *arg2 = (PyObject *) 0 ;
51081 bool result;
51082 void *argp1 = 0 ;
51083 int res1 = 0 ;
51084 PyObject * obj0 = 0 ;
51085 PyObject * obj1 = 0 ;
51086 char * kwnames[] = {
51087 (char *) "self",(char *) "item", NULL
51088 };
51089
51090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51092 if (!SWIG_IsOK(res1)) {
51093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51094 }
51095 arg1 = reinterpret_cast< wxSizer * >(argp1);
51096 arg2 = obj1;
51097 {
51098 PyThreadState* __tstate = wxPyBeginAllowThreads();
51099 result = (bool)wxSizer_IsShown(arg1,arg2);
51100 wxPyEndAllowThreads(__tstate);
51101 if (PyErr_Occurred()) SWIG_fail;
51102 }
51103 {
51104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51105 }
51106 return resultobj;
51107 fail:
51108 return NULL;
51109 }
51110
51111
51112 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51113 PyObject *resultobj = 0;
51114 wxSizer *arg1 = (wxSizer *) 0 ;
51115 bool arg2 ;
51116 void *argp1 = 0 ;
51117 int res1 = 0 ;
51118 bool val2 ;
51119 int ecode2 = 0 ;
51120 PyObject * obj0 = 0 ;
51121 PyObject * obj1 = 0 ;
51122 char * kwnames[] = {
51123 (char *) "self",(char *) "show", NULL
51124 };
51125
51126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51128 if (!SWIG_IsOK(res1)) {
51129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51130 }
51131 arg1 = reinterpret_cast< wxSizer * >(argp1);
51132 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51133 if (!SWIG_IsOK(ecode2)) {
51134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51135 }
51136 arg2 = static_cast< bool >(val2);
51137 {
51138 PyThreadState* __tstate = wxPyBeginAllowThreads();
51139 (arg1)->ShowItems(arg2);
51140 wxPyEndAllowThreads(__tstate);
51141 if (PyErr_Occurred()) SWIG_fail;
51142 }
51143 resultobj = SWIG_Py_Void();
51144 return resultobj;
51145 fail:
51146 return NULL;
51147 }
51148
51149
51150 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51151 PyObject *obj;
51152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51153 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51154 return SWIG_Py_Void();
51155 }
51156
51157 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51158 PyObject *resultobj = 0;
51159 wxPySizer *result = 0 ;
51160
51161 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51162 {
51163 PyThreadState* __tstate = wxPyBeginAllowThreads();
51164 result = (wxPySizer *)new wxPySizer();
51165 wxPyEndAllowThreads(__tstate);
51166 if (PyErr_Occurred()) SWIG_fail;
51167 }
51168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51169 return resultobj;
51170 fail:
51171 return NULL;
51172 }
51173
51174
51175 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51176 PyObject *resultobj = 0;
51177 wxPySizer *arg1 = (wxPySizer *) 0 ;
51178 PyObject *arg2 = (PyObject *) 0 ;
51179 PyObject *arg3 = (PyObject *) 0 ;
51180 void *argp1 = 0 ;
51181 int res1 = 0 ;
51182 PyObject * obj0 = 0 ;
51183 PyObject * obj1 = 0 ;
51184 PyObject * obj2 = 0 ;
51185 char * kwnames[] = {
51186 (char *) "self",(char *) "self",(char *) "_class", NULL
51187 };
51188
51189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51191 if (!SWIG_IsOK(res1)) {
51192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51193 }
51194 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51195 arg2 = obj1;
51196 arg3 = obj2;
51197 {
51198 PyThreadState* __tstate = wxPyBeginAllowThreads();
51199 (arg1)->_setCallbackInfo(arg2,arg3);
51200 wxPyEndAllowThreads(__tstate);
51201 if (PyErr_Occurred()) SWIG_fail;
51202 }
51203 resultobj = SWIG_Py_Void();
51204 return resultobj;
51205 fail:
51206 return NULL;
51207 }
51208
51209
51210 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51211 PyObject *obj;
51212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51213 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51214 return SWIG_Py_Void();
51215 }
51216
51217 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51218 return SWIG_Python_InitShadowInstance(args);
51219 }
51220
51221 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51222 PyObject *resultobj = 0;
51223 int arg1 = (int) wxHORIZONTAL ;
51224 wxBoxSizer *result = 0 ;
51225 int val1 ;
51226 int ecode1 = 0 ;
51227 PyObject * obj0 = 0 ;
51228 char * kwnames[] = {
51229 (char *) "orient", NULL
51230 };
51231
51232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51233 if (obj0) {
51234 ecode1 = SWIG_AsVal_int(obj0, &val1);
51235 if (!SWIG_IsOK(ecode1)) {
51236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51237 }
51238 arg1 = static_cast< int >(val1);
51239 }
51240 {
51241 PyThreadState* __tstate = wxPyBeginAllowThreads();
51242 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51243 wxPyEndAllowThreads(__tstate);
51244 if (PyErr_Occurred()) SWIG_fail;
51245 }
51246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51247 return resultobj;
51248 fail:
51249 return NULL;
51250 }
51251
51252
51253 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51254 PyObject *resultobj = 0;
51255 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51256 int result;
51257 void *argp1 = 0 ;
51258 int res1 = 0 ;
51259 PyObject *swig_obj[1] ;
51260
51261 if (!args) SWIG_fail;
51262 swig_obj[0] = args;
51263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51264 if (!SWIG_IsOK(res1)) {
51265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51266 }
51267 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51268 {
51269 PyThreadState* __tstate = wxPyBeginAllowThreads();
51270 result = (int)(arg1)->GetOrientation();
51271 wxPyEndAllowThreads(__tstate);
51272 if (PyErr_Occurred()) SWIG_fail;
51273 }
51274 resultobj = SWIG_From_int(static_cast< int >(result));
51275 return resultobj;
51276 fail:
51277 return NULL;
51278 }
51279
51280
51281 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51282 PyObject *resultobj = 0;
51283 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51284 int arg2 ;
51285 void *argp1 = 0 ;
51286 int res1 = 0 ;
51287 int val2 ;
51288 int ecode2 = 0 ;
51289 PyObject * obj0 = 0 ;
51290 PyObject * obj1 = 0 ;
51291 char * kwnames[] = {
51292 (char *) "self",(char *) "orient", NULL
51293 };
51294
51295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51297 if (!SWIG_IsOK(res1)) {
51298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51299 }
51300 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51301 ecode2 = SWIG_AsVal_int(obj1, &val2);
51302 if (!SWIG_IsOK(ecode2)) {
51303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51304 }
51305 arg2 = static_cast< int >(val2);
51306 {
51307 PyThreadState* __tstate = wxPyBeginAllowThreads();
51308 (arg1)->SetOrientation(arg2);
51309 wxPyEndAllowThreads(__tstate);
51310 if (PyErr_Occurred()) SWIG_fail;
51311 }
51312 resultobj = SWIG_Py_Void();
51313 return resultobj;
51314 fail:
51315 return NULL;
51316 }
51317
51318
51319 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51320 PyObject *obj;
51321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51322 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51323 return SWIG_Py_Void();
51324 }
51325
51326 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51327 return SWIG_Python_InitShadowInstance(args);
51328 }
51329
51330 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51331 PyObject *resultobj = 0;
51332 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51333 int arg2 = (int) wxHORIZONTAL ;
51334 wxStaticBoxSizer *result = 0 ;
51335 void *argp1 = 0 ;
51336 int res1 = 0 ;
51337 int val2 ;
51338 int ecode2 = 0 ;
51339 PyObject * obj0 = 0 ;
51340 PyObject * obj1 = 0 ;
51341 char * kwnames[] = {
51342 (char *) "box",(char *) "orient", NULL
51343 };
51344
51345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51347 if (!SWIG_IsOK(res1)) {
51348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51349 }
51350 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51351 if (obj1) {
51352 ecode2 = SWIG_AsVal_int(obj1, &val2);
51353 if (!SWIG_IsOK(ecode2)) {
51354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51355 }
51356 arg2 = static_cast< int >(val2);
51357 }
51358 {
51359 PyThreadState* __tstate = wxPyBeginAllowThreads();
51360 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51361 wxPyEndAllowThreads(__tstate);
51362 if (PyErr_Occurred()) SWIG_fail;
51363 }
51364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51365 return resultobj;
51366 fail:
51367 return NULL;
51368 }
51369
51370
51371 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51372 PyObject *resultobj = 0;
51373 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51374 wxStaticBox *result = 0 ;
51375 void *argp1 = 0 ;
51376 int res1 = 0 ;
51377 PyObject *swig_obj[1] ;
51378
51379 if (!args) SWIG_fail;
51380 swig_obj[0] = args;
51381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51382 if (!SWIG_IsOK(res1)) {
51383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51384 }
51385 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51386 {
51387 PyThreadState* __tstate = wxPyBeginAllowThreads();
51388 result = (wxStaticBox *)(arg1)->GetStaticBox();
51389 wxPyEndAllowThreads(__tstate);
51390 if (PyErr_Occurred()) SWIG_fail;
51391 }
51392 {
51393 resultobj = wxPyMake_wxObject(result, (bool)0);
51394 }
51395 return resultobj;
51396 fail:
51397 return NULL;
51398 }
51399
51400
51401 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51402 PyObject *obj;
51403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51404 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51405 return SWIG_Py_Void();
51406 }
51407
51408 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51409 return SWIG_Python_InitShadowInstance(args);
51410 }
51411
51412 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51413 PyObject *resultobj = 0;
51414 int arg1 = (int) 1 ;
51415 int arg2 = (int) 0 ;
51416 int arg3 = (int) 0 ;
51417 int arg4 = (int) 0 ;
51418 wxGridSizer *result = 0 ;
51419 int val1 ;
51420 int ecode1 = 0 ;
51421 int val2 ;
51422 int ecode2 = 0 ;
51423 int val3 ;
51424 int ecode3 = 0 ;
51425 int val4 ;
51426 int ecode4 = 0 ;
51427 PyObject * obj0 = 0 ;
51428 PyObject * obj1 = 0 ;
51429 PyObject * obj2 = 0 ;
51430 PyObject * obj3 = 0 ;
51431 char * kwnames[] = {
51432 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51433 };
51434
51435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51436 if (obj0) {
51437 ecode1 = SWIG_AsVal_int(obj0, &val1);
51438 if (!SWIG_IsOK(ecode1)) {
51439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51440 }
51441 arg1 = static_cast< int >(val1);
51442 }
51443 if (obj1) {
51444 ecode2 = SWIG_AsVal_int(obj1, &val2);
51445 if (!SWIG_IsOK(ecode2)) {
51446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51447 }
51448 arg2 = static_cast< int >(val2);
51449 }
51450 if (obj2) {
51451 ecode3 = SWIG_AsVal_int(obj2, &val3);
51452 if (!SWIG_IsOK(ecode3)) {
51453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51454 }
51455 arg3 = static_cast< int >(val3);
51456 }
51457 if (obj3) {
51458 ecode4 = SWIG_AsVal_int(obj3, &val4);
51459 if (!SWIG_IsOK(ecode4)) {
51460 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51461 }
51462 arg4 = static_cast< int >(val4);
51463 }
51464 {
51465 PyThreadState* __tstate = wxPyBeginAllowThreads();
51466 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51467 wxPyEndAllowThreads(__tstate);
51468 if (PyErr_Occurred()) SWIG_fail;
51469 }
51470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51471 return resultobj;
51472 fail:
51473 return NULL;
51474 }
51475
51476
51477 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51478 PyObject *resultobj = 0;
51479 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51480 int arg2 ;
51481 void *argp1 = 0 ;
51482 int res1 = 0 ;
51483 int val2 ;
51484 int ecode2 = 0 ;
51485 PyObject * obj0 = 0 ;
51486 PyObject * obj1 = 0 ;
51487 char * kwnames[] = {
51488 (char *) "self",(char *) "cols", NULL
51489 };
51490
51491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51493 if (!SWIG_IsOK(res1)) {
51494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51495 }
51496 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51497 ecode2 = SWIG_AsVal_int(obj1, &val2);
51498 if (!SWIG_IsOK(ecode2)) {
51499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51500 }
51501 arg2 = static_cast< int >(val2);
51502 {
51503 PyThreadState* __tstate = wxPyBeginAllowThreads();
51504 (arg1)->SetCols(arg2);
51505 wxPyEndAllowThreads(__tstate);
51506 if (PyErr_Occurred()) SWIG_fail;
51507 }
51508 resultobj = SWIG_Py_Void();
51509 return resultobj;
51510 fail:
51511 return NULL;
51512 }
51513
51514
51515 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51516 PyObject *resultobj = 0;
51517 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51518 int arg2 ;
51519 void *argp1 = 0 ;
51520 int res1 = 0 ;
51521 int val2 ;
51522 int ecode2 = 0 ;
51523 PyObject * obj0 = 0 ;
51524 PyObject * obj1 = 0 ;
51525 char * kwnames[] = {
51526 (char *) "self",(char *) "rows", NULL
51527 };
51528
51529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51531 if (!SWIG_IsOK(res1)) {
51532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51533 }
51534 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51535 ecode2 = SWIG_AsVal_int(obj1, &val2);
51536 if (!SWIG_IsOK(ecode2)) {
51537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51538 }
51539 arg2 = static_cast< int >(val2);
51540 {
51541 PyThreadState* __tstate = wxPyBeginAllowThreads();
51542 (arg1)->SetRows(arg2);
51543 wxPyEndAllowThreads(__tstate);
51544 if (PyErr_Occurred()) SWIG_fail;
51545 }
51546 resultobj = SWIG_Py_Void();
51547 return resultobj;
51548 fail:
51549 return NULL;
51550 }
51551
51552
51553 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51554 PyObject *resultobj = 0;
51555 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51556 int arg2 ;
51557 void *argp1 = 0 ;
51558 int res1 = 0 ;
51559 int val2 ;
51560 int ecode2 = 0 ;
51561 PyObject * obj0 = 0 ;
51562 PyObject * obj1 = 0 ;
51563 char * kwnames[] = {
51564 (char *) "self",(char *) "gap", NULL
51565 };
51566
51567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51569 if (!SWIG_IsOK(res1)) {
51570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51571 }
51572 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51573 ecode2 = SWIG_AsVal_int(obj1, &val2);
51574 if (!SWIG_IsOK(ecode2)) {
51575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51576 }
51577 arg2 = static_cast< int >(val2);
51578 {
51579 PyThreadState* __tstate = wxPyBeginAllowThreads();
51580 (arg1)->SetVGap(arg2);
51581 wxPyEndAllowThreads(__tstate);
51582 if (PyErr_Occurred()) SWIG_fail;
51583 }
51584 resultobj = SWIG_Py_Void();
51585 return resultobj;
51586 fail:
51587 return NULL;
51588 }
51589
51590
51591 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51592 PyObject *resultobj = 0;
51593 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51594 int arg2 ;
51595 void *argp1 = 0 ;
51596 int res1 = 0 ;
51597 int val2 ;
51598 int ecode2 = 0 ;
51599 PyObject * obj0 = 0 ;
51600 PyObject * obj1 = 0 ;
51601 char * kwnames[] = {
51602 (char *) "self",(char *) "gap", NULL
51603 };
51604
51605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51607 if (!SWIG_IsOK(res1)) {
51608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51609 }
51610 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51611 ecode2 = SWIG_AsVal_int(obj1, &val2);
51612 if (!SWIG_IsOK(ecode2)) {
51613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51614 }
51615 arg2 = static_cast< int >(val2);
51616 {
51617 PyThreadState* __tstate = wxPyBeginAllowThreads();
51618 (arg1)->SetHGap(arg2);
51619 wxPyEndAllowThreads(__tstate);
51620 if (PyErr_Occurred()) SWIG_fail;
51621 }
51622 resultobj = SWIG_Py_Void();
51623 return resultobj;
51624 fail:
51625 return NULL;
51626 }
51627
51628
51629 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51630 PyObject *resultobj = 0;
51631 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51632 int result;
51633 void *argp1 = 0 ;
51634 int res1 = 0 ;
51635 PyObject *swig_obj[1] ;
51636
51637 if (!args) SWIG_fail;
51638 swig_obj[0] = args;
51639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51640 if (!SWIG_IsOK(res1)) {
51641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51642 }
51643 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51644 {
51645 PyThreadState* __tstate = wxPyBeginAllowThreads();
51646 result = (int)(arg1)->GetCols();
51647 wxPyEndAllowThreads(__tstate);
51648 if (PyErr_Occurred()) SWIG_fail;
51649 }
51650 resultobj = SWIG_From_int(static_cast< int >(result));
51651 return resultobj;
51652 fail:
51653 return NULL;
51654 }
51655
51656
51657 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51658 PyObject *resultobj = 0;
51659 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51660 int result;
51661 void *argp1 = 0 ;
51662 int res1 = 0 ;
51663 PyObject *swig_obj[1] ;
51664
51665 if (!args) SWIG_fail;
51666 swig_obj[0] = args;
51667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51668 if (!SWIG_IsOK(res1)) {
51669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51670 }
51671 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51672 {
51673 PyThreadState* __tstate = wxPyBeginAllowThreads();
51674 result = (int)(arg1)->GetRows();
51675 wxPyEndAllowThreads(__tstate);
51676 if (PyErr_Occurred()) SWIG_fail;
51677 }
51678 resultobj = SWIG_From_int(static_cast< int >(result));
51679 return resultobj;
51680 fail:
51681 return NULL;
51682 }
51683
51684
51685 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51686 PyObject *resultobj = 0;
51687 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51688 int result;
51689 void *argp1 = 0 ;
51690 int res1 = 0 ;
51691 PyObject *swig_obj[1] ;
51692
51693 if (!args) SWIG_fail;
51694 swig_obj[0] = args;
51695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51696 if (!SWIG_IsOK(res1)) {
51697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51698 }
51699 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51700 {
51701 PyThreadState* __tstate = wxPyBeginAllowThreads();
51702 result = (int)(arg1)->GetVGap();
51703 wxPyEndAllowThreads(__tstate);
51704 if (PyErr_Occurred()) SWIG_fail;
51705 }
51706 resultobj = SWIG_From_int(static_cast< int >(result));
51707 return resultobj;
51708 fail:
51709 return NULL;
51710 }
51711
51712
51713 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51714 PyObject *resultobj = 0;
51715 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51716 int result;
51717 void *argp1 = 0 ;
51718 int res1 = 0 ;
51719 PyObject *swig_obj[1] ;
51720
51721 if (!args) SWIG_fail;
51722 swig_obj[0] = args;
51723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51724 if (!SWIG_IsOK(res1)) {
51725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51726 }
51727 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51728 {
51729 PyThreadState* __tstate = wxPyBeginAllowThreads();
51730 result = (int)(arg1)->GetHGap();
51731 wxPyEndAllowThreads(__tstate);
51732 if (PyErr_Occurred()) SWIG_fail;
51733 }
51734 resultobj = SWIG_From_int(static_cast< int >(result));
51735 return resultobj;
51736 fail:
51737 return NULL;
51738 }
51739
51740
51741 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51742 PyObject *obj;
51743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51744 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51745 return SWIG_Py_Void();
51746 }
51747
51748 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51749 return SWIG_Python_InitShadowInstance(args);
51750 }
51751
51752 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51753 PyObject *resultobj = 0;
51754 int arg1 = (int) 1 ;
51755 int arg2 = (int) 0 ;
51756 int arg3 = (int) 0 ;
51757 int arg4 = (int) 0 ;
51758 wxFlexGridSizer *result = 0 ;
51759 int val1 ;
51760 int ecode1 = 0 ;
51761 int val2 ;
51762 int ecode2 = 0 ;
51763 int val3 ;
51764 int ecode3 = 0 ;
51765 int val4 ;
51766 int ecode4 = 0 ;
51767 PyObject * obj0 = 0 ;
51768 PyObject * obj1 = 0 ;
51769 PyObject * obj2 = 0 ;
51770 PyObject * obj3 = 0 ;
51771 char * kwnames[] = {
51772 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51773 };
51774
51775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51776 if (obj0) {
51777 ecode1 = SWIG_AsVal_int(obj0, &val1);
51778 if (!SWIG_IsOK(ecode1)) {
51779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51780 }
51781 arg1 = static_cast< int >(val1);
51782 }
51783 if (obj1) {
51784 ecode2 = SWIG_AsVal_int(obj1, &val2);
51785 if (!SWIG_IsOK(ecode2)) {
51786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51787 }
51788 arg2 = static_cast< int >(val2);
51789 }
51790 if (obj2) {
51791 ecode3 = SWIG_AsVal_int(obj2, &val3);
51792 if (!SWIG_IsOK(ecode3)) {
51793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51794 }
51795 arg3 = static_cast< int >(val3);
51796 }
51797 if (obj3) {
51798 ecode4 = SWIG_AsVal_int(obj3, &val4);
51799 if (!SWIG_IsOK(ecode4)) {
51800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51801 }
51802 arg4 = static_cast< int >(val4);
51803 }
51804 {
51805 PyThreadState* __tstate = wxPyBeginAllowThreads();
51806 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51807 wxPyEndAllowThreads(__tstate);
51808 if (PyErr_Occurred()) SWIG_fail;
51809 }
51810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51811 return resultobj;
51812 fail:
51813 return NULL;
51814 }
51815
51816
51817 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51818 PyObject *resultobj = 0;
51819 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51820 size_t arg2 ;
51821 int arg3 = (int) 0 ;
51822 void *argp1 = 0 ;
51823 int res1 = 0 ;
51824 size_t val2 ;
51825 int ecode2 = 0 ;
51826 int val3 ;
51827 int ecode3 = 0 ;
51828 PyObject * obj0 = 0 ;
51829 PyObject * obj1 = 0 ;
51830 PyObject * obj2 = 0 ;
51831 char * kwnames[] = {
51832 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51833 };
51834
51835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51837 if (!SWIG_IsOK(res1)) {
51838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51839 }
51840 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51841 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51842 if (!SWIG_IsOK(ecode2)) {
51843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51844 }
51845 arg2 = static_cast< size_t >(val2);
51846 if (obj2) {
51847 ecode3 = SWIG_AsVal_int(obj2, &val3);
51848 if (!SWIG_IsOK(ecode3)) {
51849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51850 }
51851 arg3 = static_cast< int >(val3);
51852 }
51853 {
51854 PyThreadState* __tstate = wxPyBeginAllowThreads();
51855 (arg1)->AddGrowableRow(arg2,arg3);
51856 wxPyEndAllowThreads(__tstate);
51857 if (PyErr_Occurred()) SWIG_fail;
51858 }
51859 resultobj = SWIG_Py_Void();
51860 return resultobj;
51861 fail:
51862 return NULL;
51863 }
51864
51865
51866 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51867 PyObject *resultobj = 0;
51868 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51869 size_t arg2 ;
51870 void *argp1 = 0 ;
51871 int res1 = 0 ;
51872 size_t val2 ;
51873 int ecode2 = 0 ;
51874 PyObject * obj0 = 0 ;
51875 PyObject * obj1 = 0 ;
51876 char * kwnames[] = {
51877 (char *) "self",(char *) "idx", NULL
51878 };
51879
51880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51882 if (!SWIG_IsOK(res1)) {
51883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51884 }
51885 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51886 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51887 if (!SWIG_IsOK(ecode2)) {
51888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51889 }
51890 arg2 = static_cast< size_t >(val2);
51891 {
51892 PyThreadState* __tstate = wxPyBeginAllowThreads();
51893 (arg1)->RemoveGrowableRow(arg2);
51894 wxPyEndAllowThreads(__tstate);
51895 if (PyErr_Occurred()) SWIG_fail;
51896 }
51897 resultobj = SWIG_Py_Void();
51898 return resultobj;
51899 fail:
51900 return NULL;
51901 }
51902
51903
51904 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51905 PyObject *resultobj = 0;
51906 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51907 size_t arg2 ;
51908 int arg3 = (int) 0 ;
51909 void *argp1 = 0 ;
51910 int res1 = 0 ;
51911 size_t val2 ;
51912 int ecode2 = 0 ;
51913 int val3 ;
51914 int ecode3 = 0 ;
51915 PyObject * obj0 = 0 ;
51916 PyObject * obj1 = 0 ;
51917 PyObject * obj2 = 0 ;
51918 char * kwnames[] = {
51919 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51920 };
51921
51922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51924 if (!SWIG_IsOK(res1)) {
51925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51926 }
51927 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51928 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51929 if (!SWIG_IsOK(ecode2)) {
51930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51931 }
51932 arg2 = static_cast< size_t >(val2);
51933 if (obj2) {
51934 ecode3 = SWIG_AsVal_int(obj2, &val3);
51935 if (!SWIG_IsOK(ecode3)) {
51936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51937 }
51938 arg3 = static_cast< int >(val3);
51939 }
51940 {
51941 PyThreadState* __tstate = wxPyBeginAllowThreads();
51942 (arg1)->AddGrowableCol(arg2,arg3);
51943 wxPyEndAllowThreads(__tstate);
51944 if (PyErr_Occurred()) SWIG_fail;
51945 }
51946 resultobj = SWIG_Py_Void();
51947 return resultobj;
51948 fail:
51949 return NULL;
51950 }
51951
51952
51953 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51954 PyObject *resultobj = 0;
51955 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51956 size_t arg2 ;
51957 void *argp1 = 0 ;
51958 int res1 = 0 ;
51959 size_t val2 ;
51960 int ecode2 = 0 ;
51961 PyObject * obj0 = 0 ;
51962 PyObject * obj1 = 0 ;
51963 char * kwnames[] = {
51964 (char *) "self",(char *) "idx", NULL
51965 };
51966
51967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51969 if (!SWIG_IsOK(res1)) {
51970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51971 }
51972 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51973 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51974 if (!SWIG_IsOK(ecode2)) {
51975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51976 }
51977 arg2 = static_cast< size_t >(val2);
51978 {
51979 PyThreadState* __tstate = wxPyBeginAllowThreads();
51980 (arg1)->RemoveGrowableCol(arg2);
51981 wxPyEndAllowThreads(__tstate);
51982 if (PyErr_Occurred()) SWIG_fail;
51983 }
51984 resultobj = SWIG_Py_Void();
51985 return resultobj;
51986 fail:
51987 return NULL;
51988 }
51989
51990
51991 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51992 PyObject *resultobj = 0;
51993 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51994 int arg2 ;
51995 void *argp1 = 0 ;
51996 int res1 = 0 ;
51997 int val2 ;
51998 int ecode2 = 0 ;
51999 PyObject * obj0 = 0 ;
52000 PyObject * obj1 = 0 ;
52001 char * kwnames[] = {
52002 (char *) "self",(char *) "direction", NULL
52003 };
52004
52005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52007 if (!SWIG_IsOK(res1)) {
52008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52009 }
52010 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52011 ecode2 = SWIG_AsVal_int(obj1, &val2);
52012 if (!SWIG_IsOK(ecode2)) {
52013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52014 }
52015 arg2 = static_cast< int >(val2);
52016 {
52017 PyThreadState* __tstate = wxPyBeginAllowThreads();
52018 (arg1)->SetFlexibleDirection(arg2);
52019 wxPyEndAllowThreads(__tstate);
52020 if (PyErr_Occurred()) SWIG_fail;
52021 }
52022 resultobj = SWIG_Py_Void();
52023 return resultobj;
52024 fail:
52025 return NULL;
52026 }
52027
52028
52029 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52030 PyObject *resultobj = 0;
52031 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52032 int result;
52033 void *argp1 = 0 ;
52034 int res1 = 0 ;
52035 PyObject *swig_obj[1] ;
52036
52037 if (!args) SWIG_fail;
52038 swig_obj[0] = args;
52039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52040 if (!SWIG_IsOK(res1)) {
52041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52042 }
52043 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52044 {
52045 PyThreadState* __tstate = wxPyBeginAllowThreads();
52046 result = (int)(arg1)->GetFlexibleDirection();
52047 wxPyEndAllowThreads(__tstate);
52048 if (PyErr_Occurred()) SWIG_fail;
52049 }
52050 resultobj = SWIG_From_int(static_cast< int >(result));
52051 return resultobj;
52052 fail:
52053 return NULL;
52054 }
52055
52056
52057 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52058 PyObject *resultobj = 0;
52059 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52060 wxFlexSizerGrowMode arg2 ;
52061 void *argp1 = 0 ;
52062 int res1 = 0 ;
52063 int val2 ;
52064 int ecode2 = 0 ;
52065 PyObject * obj0 = 0 ;
52066 PyObject * obj1 = 0 ;
52067 char * kwnames[] = {
52068 (char *) "self",(char *) "mode", NULL
52069 };
52070
52071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52073 if (!SWIG_IsOK(res1)) {
52074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52075 }
52076 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52077 ecode2 = SWIG_AsVal_int(obj1, &val2);
52078 if (!SWIG_IsOK(ecode2)) {
52079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52080 }
52081 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52082 {
52083 PyThreadState* __tstate = wxPyBeginAllowThreads();
52084 (arg1)->SetNonFlexibleGrowMode(arg2);
52085 wxPyEndAllowThreads(__tstate);
52086 if (PyErr_Occurred()) SWIG_fail;
52087 }
52088 resultobj = SWIG_Py_Void();
52089 return resultobj;
52090 fail:
52091 return NULL;
52092 }
52093
52094
52095 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52096 PyObject *resultobj = 0;
52097 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52098 wxFlexSizerGrowMode result;
52099 void *argp1 = 0 ;
52100 int res1 = 0 ;
52101 PyObject *swig_obj[1] ;
52102
52103 if (!args) SWIG_fail;
52104 swig_obj[0] = args;
52105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52106 if (!SWIG_IsOK(res1)) {
52107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52108 }
52109 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52110 {
52111 PyThreadState* __tstate = wxPyBeginAllowThreads();
52112 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52113 wxPyEndAllowThreads(__tstate);
52114 if (PyErr_Occurred()) SWIG_fail;
52115 }
52116 resultobj = SWIG_From_int(static_cast< int >(result));
52117 return resultobj;
52118 fail:
52119 return NULL;
52120 }
52121
52122
52123 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52124 PyObject *resultobj = 0;
52125 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52126 wxArrayInt *result = 0 ;
52127 void *argp1 = 0 ;
52128 int res1 = 0 ;
52129 PyObject *swig_obj[1] ;
52130
52131 if (!args) SWIG_fail;
52132 swig_obj[0] = args;
52133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52134 if (!SWIG_IsOK(res1)) {
52135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52136 }
52137 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52138 {
52139 PyThreadState* __tstate = wxPyBeginAllowThreads();
52140 {
52141 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52142 result = (wxArrayInt *) &_result_ref;
52143 }
52144 wxPyEndAllowThreads(__tstate);
52145 if (PyErr_Occurred()) SWIG_fail;
52146 }
52147 {
52148 resultobj = wxArrayInt2PyList_helper(*result);
52149 }
52150 return resultobj;
52151 fail:
52152 return NULL;
52153 }
52154
52155
52156 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52157 PyObject *resultobj = 0;
52158 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52159 wxArrayInt *result = 0 ;
52160 void *argp1 = 0 ;
52161 int res1 = 0 ;
52162 PyObject *swig_obj[1] ;
52163
52164 if (!args) SWIG_fail;
52165 swig_obj[0] = args;
52166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52167 if (!SWIG_IsOK(res1)) {
52168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52169 }
52170 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52171 {
52172 PyThreadState* __tstate = wxPyBeginAllowThreads();
52173 {
52174 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52175 result = (wxArrayInt *) &_result_ref;
52176 }
52177 wxPyEndAllowThreads(__tstate);
52178 if (PyErr_Occurred()) SWIG_fail;
52179 }
52180 {
52181 resultobj = wxArrayInt2PyList_helper(*result);
52182 }
52183 return resultobj;
52184 fail:
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52190 PyObject *obj;
52191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52192 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52193 return SWIG_Py_Void();
52194 }
52195
52196 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52197 return SWIG_Python_InitShadowInstance(args);
52198 }
52199
52200 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52201 PyObject *resultobj = 0;
52202 wxStdDialogButtonSizer *result = 0 ;
52203
52204 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52205 {
52206 PyThreadState* __tstate = wxPyBeginAllowThreads();
52207 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52208 wxPyEndAllowThreads(__tstate);
52209 if (PyErr_Occurred()) SWIG_fail;
52210 }
52211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52212 return resultobj;
52213 fail:
52214 return NULL;
52215 }
52216
52217
52218 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52219 PyObject *resultobj = 0;
52220 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52221 wxButton *arg2 = (wxButton *) 0 ;
52222 void *argp1 = 0 ;
52223 int res1 = 0 ;
52224 void *argp2 = 0 ;
52225 int res2 = 0 ;
52226 PyObject * obj0 = 0 ;
52227 PyObject * obj1 = 0 ;
52228 char * kwnames[] = {
52229 (char *) "self",(char *) "button", NULL
52230 };
52231
52232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52234 if (!SWIG_IsOK(res1)) {
52235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52236 }
52237 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52239 if (!SWIG_IsOK(res2)) {
52240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52241 }
52242 arg2 = reinterpret_cast< wxButton * >(argp2);
52243 {
52244 PyThreadState* __tstate = wxPyBeginAllowThreads();
52245 (arg1)->AddButton(arg2);
52246 wxPyEndAllowThreads(__tstate);
52247 if (PyErr_Occurred()) SWIG_fail;
52248 }
52249 resultobj = SWIG_Py_Void();
52250 return resultobj;
52251 fail:
52252 return NULL;
52253 }
52254
52255
52256 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52257 PyObject *resultobj = 0;
52258 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52259 void *argp1 = 0 ;
52260 int res1 = 0 ;
52261 PyObject *swig_obj[1] ;
52262
52263 if (!args) SWIG_fail;
52264 swig_obj[0] = args;
52265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52266 if (!SWIG_IsOK(res1)) {
52267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52268 }
52269 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52270 {
52271 PyThreadState* __tstate = wxPyBeginAllowThreads();
52272 (arg1)->Realize();
52273 wxPyEndAllowThreads(__tstate);
52274 if (PyErr_Occurred()) SWIG_fail;
52275 }
52276 resultobj = SWIG_Py_Void();
52277 return resultobj;
52278 fail:
52279 return NULL;
52280 }
52281
52282
52283 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52284 PyObject *resultobj = 0;
52285 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52286 wxButton *arg2 = (wxButton *) 0 ;
52287 void *argp1 = 0 ;
52288 int res1 = 0 ;
52289 void *argp2 = 0 ;
52290 int res2 = 0 ;
52291 PyObject * obj0 = 0 ;
52292 PyObject * obj1 = 0 ;
52293 char * kwnames[] = {
52294 (char *) "self",(char *) "button", NULL
52295 };
52296
52297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52299 if (!SWIG_IsOK(res1)) {
52300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52301 }
52302 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52304 if (!SWIG_IsOK(res2)) {
52305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52306 }
52307 arg2 = reinterpret_cast< wxButton * >(argp2);
52308 {
52309 PyThreadState* __tstate = wxPyBeginAllowThreads();
52310 (arg1)->SetAffirmativeButton(arg2);
52311 wxPyEndAllowThreads(__tstate);
52312 if (PyErr_Occurred()) SWIG_fail;
52313 }
52314 resultobj = SWIG_Py_Void();
52315 return resultobj;
52316 fail:
52317 return NULL;
52318 }
52319
52320
52321 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52322 PyObject *resultobj = 0;
52323 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52324 wxButton *arg2 = (wxButton *) 0 ;
52325 void *argp1 = 0 ;
52326 int res1 = 0 ;
52327 void *argp2 = 0 ;
52328 int res2 = 0 ;
52329 PyObject * obj0 = 0 ;
52330 PyObject * obj1 = 0 ;
52331 char * kwnames[] = {
52332 (char *) "self",(char *) "button", NULL
52333 };
52334
52335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52337 if (!SWIG_IsOK(res1)) {
52338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52339 }
52340 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52341 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52342 if (!SWIG_IsOK(res2)) {
52343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52344 }
52345 arg2 = reinterpret_cast< wxButton * >(argp2);
52346 {
52347 PyThreadState* __tstate = wxPyBeginAllowThreads();
52348 (arg1)->SetNegativeButton(arg2);
52349 wxPyEndAllowThreads(__tstate);
52350 if (PyErr_Occurred()) SWIG_fail;
52351 }
52352 resultobj = SWIG_Py_Void();
52353 return resultobj;
52354 fail:
52355 return NULL;
52356 }
52357
52358
52359 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52360 PyObject *resultobj = 0;
52361 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52362 wxButton *arg2 = (wxButton *) 0 ;
52363 void *argp1 = 0 ;
52364 int res1 = 0 ;
52365 void *argp2 = 0 ;
52366 int res2 = 0 ;
52367 PyObject * obj0 = 0 ;
52368 PyObject * obj1 = 0 ;
52369 char * kwnames[] = {
52370 (char *) "self",(char *) "button", NULL
52371 };
52372
52373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52375 if (!SWIG_IsOK(res1)) {
52376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52377 }
52378 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52380 if (!SWIG_IsOK(res2)) {
52381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52382 }
52383 arg2 = reinterpret_cast< wxButton * >(argp2);
52384 {
52385 PyThreadState* __tstate = wxPyBeginAllowThreads();
52386 (arg1)->SetCancelButton(arg2);
52387 wxPyEndAllowThreads(__tstate);
52388 if (PyErr_Occurred()) SWIG_fail;
52389 }
52390 resultobj = SWIG_Py_Void();
52391 return resultobj;
52392 fail:
52393 return NULL;
52394 }
52395
52396
52397 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52398 PyObject *resultobj = 0;
52399 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52400 wxButton *result = 0 ;
52401 void *argp1 = 0 ;
52402 int res1 = 0 ;
52403 PyObject *swig_obj[1] ;
52404
52405 if (!args) SWIG_fail;
52406 swig_obj[0] = args;
52407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52408 if (!SWIG_IsOK(res1)) {
52409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52410 }
52411 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52412 {
52413 PyThreadState* __tstate = wxPyBeginAllowThreads();
52414 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52415 wxPyEndAllowThreads(__tstate);
52416 if (PyErr_Occurred()) SWIG_fail;
52417 }
52418 {
52419 resultobj = wxPyMake_wxObject(result, (bool)0);
52420 }
52421 return resultobj;
52422 fail:
52423 return NULL;
52424 }
52425
52426
52427 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52428 PyObject *resultobj = 0;
52429 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52430 wxButton *result = 0 ;
52431 void *argp1 = 0 ;
52432 int res1 = 0 ;
52433 PyObject *swig_obj[1] ;
52434
52435 if (!args) SWIG_fail;
52436 swig_obj[0] = args;
52437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52438 if (!SWIG_IsOK(res1)) {
52439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52440 }
52441 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52442 {
52443 PyThreadState* __tstate = wxPyBeginAllowThreads();
52444 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52445 wxPyEndAllowThreads(__tstate);
52446 if (PyErr_Occurred()) SWIG_fail;
52447 }
52448 {
52449 resultobj = wxPyMake_wxObject(result, (bool)0);
52450 }
52451 return resultobj;
52452 fail:
52453 return NULL;
52454 }
52455
52456
52457 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52458 PyObject *resultobj = 0;
52459 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52460 wxButton *result = 0 ;
52461 void *argp1 = 0 ;
52462 int res1 = 0 ;
52463 PyObject *swig_obj[1] ;
52464
52465 if (!args) SWIG_fail;
52466 swig_obj[0] = args;
52467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52468 if (!SWIG_IsOK(res1)) {
52469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52470 }
52471 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52472 {
52473 PyThreadState* __tstate = wxPyBeginAllowThreads();
52474 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52475 wxPyEndAllowThreads(__tstate);
52476 if (PyErr_Occurred()) SWIG_fail;
52477 }
52478 {
52479 resultobj = wxPyMake_wxObject(result, (bool)0);
52480 }
52481 return resultobj;
52482 fail:
52483 return NULL;
52484 }
52485
52486
52487 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52488 PyObject *resultobj = 0;
52489 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52490 wxButton *result = 0 ;
52491 void *argp1 = 0 ;
52492 int res1 = 0 ;
52493 PyObject *swig_obj[1] ;
52494
52495 if (!args) SWIG_fail;
52496 swig_obj[0] = args;
52497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52498 if (!SWIG_IsOK(res1)) {
52499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52500 }
52501 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52502 {
52503 PyThreadState* __tstate = wxPyBeginAllowThreads();
52504 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52505 wxPyEndAllowThreads(__tstate);
52506 if (PyErr_Occurred()) SWIG_fail;
52507 }
52508 {
52509 resultobj = wxPyMake_wxObject(result, (bool)0);
52510 }
52511 return resultobj;
52512 fail:
52513 return NULL;
52514 }
52515
52516
52517 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52518 PyObject *resultobj = 0;
52519 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52520 wxButton *result = 0 ;
52521 void *argp1 = 0 ;
52522 int res1 = 0 ;
52523 PyObject *swig_obj[1] ;
52524
52525 if (!args) SWIG_fail;
52526 swig_obj[0] = args;
52527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52528 if (!SWIG_IsOK(res1)) {
52529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52530 }
52531 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52532 {
52533 PyThreadState* __tstate = wxPyBeginAllowThreads();
52534 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52535 wxPyEndAllowThreads(__tstate);
52536 if (PyErr_Occurred()) SWIG_fail;
52537 }
52538 {
52539 resultobj = wxPyMake_wxObject(result, (bool)0);
52540 }
52541 return resultobj;
52542 fail:
52543 return NULL;
52544 }
52545
52546
52547 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52548 PyObject *obj;
52549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52550 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52551 return SWIG_Py_Void();
52552 }
52553
52554 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52555 return SWIG_Python_InitShadowInstance(args);
52556 }
52557
52558 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52559 PyObject *resultobj = 0;
52560 int arg1 = (int) 0 ;
52561 int arg2 = (int) 0 ;
52562 wxGBPosition *result = 0 ;
52563 int val1 ;
52564 int ecode1 = 0 ;
52565 int val2 ;
52566 int ecode2 = 0 ;
52567 PyObject * obj0 = 0 ;
52568 PyObject * obj1 = 0 ;
52569 char * kwnames[] = {
52570 (char *) "row",(char *) "col", NULL
52571 };
52572
52573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52574 if (obj0) {
52575 ecode1 = SWIG_AsVal_int(obj0, &val1);
52576 if (!SWIG_IsOK(ecode1)) {
52577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52578 }
52579 arg1 = static_cast< int >(val1);
52580 }
52581 if (obj1) {
52582 ecode2 = SWIG_AsVal_int(obj1, &val2);
52583 if (!SWIG_IsOK(ecode2)) {
52584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52585 }
52586 arg2 = static_cast< int >(val2);
52587 }
52588 {
52589 PyThreadState* __tstate = wxPyBeginAllowThreads();
52590 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52591 wxPyEndAllowThreads(__tstate);
52592 if (PyErr_Occurred()) SWIG_fail;
52593 }
52594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52595 return resultobj;
52596 fail:
52597 return NULL;
52598 }
52599
52600
52601 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52602 PyObject *resultobj = 0;
52603 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52604 void *argp1 = 0 ;
52605 int res1 = 0 ;
52606 PyObject *swig_obj[1] ;
52607
52608 if (!args) SWIG_fail;
52609 swig_obj[0] = args;
52610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52611 if (!SWIG_IsOK(res1)) {
52612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52613 }
52614 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52615 {
52616 PyThreadState* __tstate = wxPyBeginAllowThreads();
52617 delete arg1;
52618
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_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52630 PyObject *resultobj = 0;
52631 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52632 int result;
52633 void *argp1 = 0 ;
52634 int res1 = 0 ;
52635 PyObject *swig_obj[1] ;
52636
52637 if (!args) SWIG_fail;
52638 swig_obj[0] = args;
52639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52640 if (!SWIG_IsOK(res1)) {
52641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52642 }
52643 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52644 {
52645 PyThreadState* __tstate = wxPyBeginAllowThreads();
52646 result = (int)((wxGBPosition const *)arg1)->GetRow();
52647 wxPyEndAllowThreads(__tstate);
52648 if (PyErr_Occurred()) SWIG_fail;
52649 }
52650 resultobj = SWIG_From_int(static_cast< int >(result));
52651 return resultobj;
52652 fail:
52653 return NULL;
52654 }
52655
52656
52657 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52658 PyObject *resultobj = 0;
52659 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52660 int result;
52661 void *argp1 = 0 ;
52662 int res1 = 0 ;
52663 PyObject *swig_obj[1] ;
52664
52665 if (!args) SWIG_fail;
52666 swig_obj[0] = args;
52667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52668 if (!SWIG_IsOK(res1)) {
52669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52670 }
52671 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52672 {
52673 PyThreadState* __tstate = wxPyBeginAllowThreads();
52674 result = (int)((wxGBPosition const *)arg1)->GetCol();
52675 wxPyEndAllowThreads(__tstate);
52676 if (PyErr_Occurred()) SWIG_fail;
52677 }
52678 resultobj = SWIG_From_int(static_cast< int >(result));
52679 return resultobj;
52680 fail:
52681 return NULL;
52682 }
52683
52684
52685 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52686 PyObject *resultobj = 0;
52687 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52688 int arg2 ;
52689 void *argp1 = 0 ;
52690 int res1 = 0 ;
52691 int val2 ;
52692 int ecode2 = 0 ;
52693 PyObject * obj0 = 0 ;
52694 PyObject * obj1 = 0 ;
52695 char * kwnames[] = {
52696 (char *) "self",(char *) "row", NULL
52697 };
52698
52699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52701 if (!SWIG_IsOK(res1)) {
52702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52703 }
52704 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52705 ecode2 = SWIG_AsVal_int(obj1, &val2);
52706 if (!SWIG_IsOK(ecode2)) {
52707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52708 }
52709 arg2 = static_cast< int >(val2);
52710 {
52711 PyThreadState* __tstate = wxPyBeginAllowThreads();
52712 (arg1)->SetRow(arg2);
52713 wxPyEndAllowThreads(__tstate);
52714 if (PyErr_Occurred()) SWIG_fail;
52715 }
52716 resultobj = SWIG_Py_Void();
52717 return resultobj;
52718 fail:
52719 return NULL;
52720 }
52721
52722
52723 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52724 PyObject *resultobj = 0;
52725 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52726 int arg2 ;
52727 void *argp1 = 0 ;
52728 int res1 = 0 ;
52729 int val2 ;
52730 int ecode2 = 0 ;
52731 PyObject * obj0 = 0 ;
52732 PyObject * obj1 = 0 ;
52733 char * kwnames[] = {
52734 (char *) "self",(char *) "col", NULL
52735 };
52736
52737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52739 if (!SWIG_IsOK(res1)) {
52740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52741 }
52742 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52743 ecode2 = SWIG_AsVal_int(obj1, &val2);
52744 if (!SWIG_IsOK(ecode2)) {
52745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52746 }
52747 arg2 = static_cast< int >(val2);
52748 {
52749 PyThreadState* __tstate = wxPyBeginAllowThreads();
52750 (arg1)->SetCol(arg2);
52751 wxPyEndAllowThreads(__tstate);
52752 if (PyErr_Occurred()) SWIG_fail;
52753 }
52754 resultobj = SWIG_Py_Void();
52755 return resultobj;
52756 fail:
52757 return NULL;
52758 }
52759
52760
52761 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52762 PyObject *resultobj = 0;
52763 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52764 PyObject *arg2 = (PyObject *) 0 ;
52765 bool result;
52766 void *argp1 = 0 ;
52767 int res1 = 0 ;
52768 PyObject * obj0 = 0 ;
52769 PyObject * obj1 = 0 ;
52770 char * kwnames[] = {
52771 (char *) "self",(char *) "other", NULL
52772 };
52773
52774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52776 if (!SWIG_IsOK(res1)) {
52777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52778 }
52779 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52780 arg2 = obj1;
52781 {
52782 result = (bool)wxGBPosition___eq__(arg1,arg2);
52783 if (PyErr_Occurred()) SWIG_fail;
52784 }
52785 {
52786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52787 }
52788 return resultobj;
52789 fail:
52790 return NULL;
52791 }
52792
52793
52794 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52795 PyObject *resultobj = 0;
52796 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52797 PyObject *arg2 = (PyObject *) 0 ;
52798 bool result;
52799 void *argp1 = 0 ;
52800 int res1 = 0 ;
52801 PyObject * obj0 = 0 ;
52802 PyObject * obj1 = 0 ;
52803 char * kwnames[] = {
52804 (char *) "self",(char *) "other", NULL
52805 };
52806
52807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52809 if (!SWIG_IsOK(res1)) {
52810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52811 }
52812 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52813 arg2 = obj1;
52814 {
52815 result = (bool)wxGBPosition___ne__(arg1,arg2);
52816 if (PyErr_Occurred()) SWIG_fail;
52817 }
52818 {
52819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52820 }
52821 return resultobj;
52822 fail:
52823 return NULL;
52824 }
52825
52826
52827 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52828 PyObject *resultobj = 0;
52829 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52830 int arg2 = (int) 0 ;
52831 int arg3 = (int) 0 ;
52832 void *argp1 = 0 ;
52833 int res1 = 0 ;
52834 int val2 ;
52835 int ecode2 = 0 ;
52836 int val3 ;
52837 int ecode3 = 0 ;
52838 PyObject * obj0 = 0 ;
52839 PyObject * obj1 = 0 ;
52840 PyObject * obj2 = 0 ;
52841 char * kwnames[] = {
52842 (char *) "self",(char *) "row",(char *) "col", NULL
52843 };
52844
52845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52847 if (!SWIG_IsOK(res1)) {
52848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52849 }
52850 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52851 if (obj1) {
52852 ecode2 = SWIG_AsVal_int(obj1, &val2);
52853 if (!SWIG_IsOK(ecode2)) {
52854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52855 }
52856 arg2 = static_cast< int >(val2);
52857 }
52858 if (obj2) {
52859 ecode3 = SWIG_AsVal_int(obj2, &val3);
52860 if (!SWIG_IsOK(ecode3)) {
52861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52862 }
52863 arg3 = static_cast< int >(val3);
52864 }
52865 {
52866 PyThreadState* __tstate = wxPyBeginAllowThreads();
52867 wxGBPosition_Set(arg1,arg2,arg3);
52868 wxPyEndAllowThreads(__tstate);
52869 if (PyErr_Occurred()) SWIG_fail;
52870 }
52871 resultobj = SWIG_Py_Void();
52872 return resultobj;
52873 fail:
52874 return NULL;
52875 }
52876
52877
52878 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52879 PyObject *resultobj = 0;
52880 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52881 PyObject *result = 0 ;
52882 void *argp1 = 0 ;
52883 int res1 = 0 ;
52884 PyObject *swig_obj[1] ;
52885
52886 if (!args) SWIG_fail;
52887 swig_obj[0] = args;
52888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52889 if (!SWIG_IsOK(res1)) {
52890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52891 }
52892 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52893 {
52894 PyThreadState* __tstate = wxPyBeginAllowThreads();
52895 result = (PyObject *)wxGBPosition_Get(arg1);
52896 wxPyEndAllowThreads(__tstate);
52897 if (PyErr_Occurred()) SWIG_fail;
52898 }
52899 resultobj = result;
52900 return resultobj;
52901 fail:
52902 return NULL;
52903 }
52904
52905
52906 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52907 PyObject *obj;
52908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52909 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52910 return SWIG_Py_Void();
52911 }
52912
52913 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52914 return SWIG_Python_InitShadowInstance(args);
52915 }
52916
52917 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52918 PyObject *resultobj = 0;
52919 int arg1 = (int) 1 ;
52920 int arg2 = (int) 1 ;
52921 wxGBSpan *result = 0 ;
52922 int val1 ;
52923 int ecode1 = 0 ;
52924 int val2 ;
52925 int ecode2 = 0 ;
52926 PyObject * obj0 = 0 ;
52927 PyObject * obj1 = 0 ;
52928 char * kwnames[] = {
52929 (char *) "rowspan",(char *) "colspan", NULL
52930 };
52931
52932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52933 if (obj0) {
52934 ecode1 = SWIG_AsVal_int(obj0, &val1);
52935 if (!SWIG_IsOK(ecode1)) {
52936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52937 }
52938 arg1 = static_cast< int >(val1);
52939 }
52940 if (obj1) {
52941 ecode2 = SWIG_AsVal_int(obj1, &val2);
52942 if (!SWIG_IsOK(ecode2)) {
52943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52944 }
52945 arg2 = static_cast< int >(val2);
52946 }
52947 {
52948 PyThreadState* __tstate = wxPyBeginAllowThreads();
52949 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52950 wxPyEndAllowThreads(__tstate);
52951 if (PyErr_Occurred()) SWIG_fail;
52952 }
52953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52954 return resultobj;
52955 fail:
52956 return NULL;
52957 }
52958
52959
52960 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52961 PyObject *resultobj = 0;
52962 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52963 void *argp1 = 0 ;
52964 int res1 = 0 ;
52965 PyObject *swig_obj[1] ;
52966
52967 if (!args) SWIG_fail;
52968 swig_obj[0] = args;
52969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52970 if (!SWIG_IsOK(res1)) {
52971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52972 }
52973 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52974 {
52975 PyThreadState* __tstate = wxPyBeginAllowThreads();
52976 delete arg1;
52977
52978 wxPyEndAllowThreads(__tstate);
52979 if (PyErr_Occurred()) SWIG_fail;
52980 }
52981 resultobj = SWIG_Py_Void();
52982 return resultobj;
52983 fail:
52984 return NULL;
52985 }
52986
52987
52988 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52989 PyObject *resultobj = 0;
52990 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52991 int result;
52992 void *argp1 = 0 ;
52993 int res1 = 0 ;
52994 PyObject *swig_obj[1] ;
52995
52996 if (!args) SWIG_fail;
52997 swig_obj[0] = args;
52998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52999 if (!SWIG_IsOK(res1)) {
53000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53001 }
53002 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53003 {
53004 PyThreadState* __tstate = wxPyBeginAllowThreads();
53005 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53006 wxPyEndAllowThreads(__tstate);
53007 if (PyErr_Occurred()) SWIG_fail;
53008 }
53009 resultobj = SWIG_From_int(static_cast< int >(result));
53010 return resultobj;
53011 fail:
53012 return NULL;
53013 }
53014
53015
53016 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53017 PyObject *resultobj = 0;
53018 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53019 int result;
53020 void *argp1 = 0 ;
53021 int res1 = 0 ;
53022 PyObject *swig_obj[1] ;
53023
53024 if (!args) SWIG_fail;
53025 swig_obj[0] = args;
53026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53027 if (!SWIG_IsOK(res1)) {
53028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53029 }
53030 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53031 {
53032 PyThreadState* __tstate = wxPyBeginAllowThreads();
53033 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53034 wxPyEndAllowThreads(__tstate);
53035 if (PyErr_Occurred()) SWIG_fail;
53036 }
53037 resultobj = SWIG_From_int(static_cast< int >(result));
53038 return resultobj;
53039 fail:
53040 return NULL;
53041 }
53042
53043
53044 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53045 PyObject *resultobj = 0;
53046 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53047 int arg2 ;
53048 void *argp1 = 0 ;
53049 int res1 = 0 ;
53050 int val2 ;
53051 int ecode2 = 0 ;
53052 PyObject * obj0 = 0 ;
53053 PyObject * obj1 = 0 ;
53054 char * kwnames[] = {
53055 (char *) "self",(char *) "rowspan", NULL
53056 };
53057
53058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53060 if (!SWIG_IsOK(res1)) {
53061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53062 }
53063 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53064 ecode2 = SWIG_AsVal_int(obj1, &val2);
53065 if (!SWIG_IsOK(ecode2)) {
53066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53067 }
53068 arg2 = static_cast< int >(val2);
53069 {
53070 PyThreadState* __tstate = wxPyBeginAllowThreads();
53071 (arg1)->SetRowspan(arg2);
53072 wxPyEndAllowThreads(__tstate);
53073 if (PyErr_Occurred()) SWIG_fail;
53074 }
53075 resultobj = SWIG_Py_Void();
53076 return resultobj;
53077 fail:
53078 return NULL;
53079 }
53080
53081
53082 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53083 PyObject *resultobj = 0;
53084 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53085 int arg2 ;
53086 void *argp1 = 0 ;
53087 int res1 = 0 ;
53088 int val2 ;
53089 int ecode2 = 0 ;
53090 PyObject * obj0 = 0 ;
53091 PyObject * obj1 = 0 ;
53092 char * kwnames[] = {
53093 (char *) "self",(char *) "colspan", NULL
53094 };
53095
53096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53098 if (!SWIG_IsOK(res1)) {
53099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53100 }
53101 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53102 ecode2 = SWIG_AsVal_int(obj1, &val2);
53103 if (!SWIG_IsOK(ecode2)) {
53104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53105 }
53106 arg2 = static_cast< int >(val2);
53107 {
53108 PyThreadState* __tstate = wxPyBeginAllowThreads();
53109 (arg1)->SetColspan(arg2);
53110 wxPyEndAllowThreads(__tstate);
53111 if (PyErr_Occurred()) SWIG_fail;
53112 }
53113 resultobj = SWIG_Py_Void();
53114 return resultobj;
53115 fail:
53116 return NULL;
53117 }
53118
53119
53120 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53121 PyObject *resultobj = 0;
53122 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53123 PyObject *arg2 = (PyObject *) 0 ;
53124 bool result;
53125 void *argp1 = 0 ;
53126 int res1 = 0 ;
53127 PyObject * obj0 = 0 ;
53128 PyObject * obj1 = 0 ;
53129 char * kwnames[] = {
53130 (char *) "self",(char *) "other", NULL
53131 };
53132
53133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53135 if (!SWIG_IsOK(res1)) {
53136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53137 }
53138 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53139 arg2 = obj1;
53140 {
53141 result = (bool)wxGBSpan___eq__(arg1,arg2);
53142 if (PyErr_Occurred()) SWIG_fail;
53143 }
53144 {
53145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53146 }
53147 return resultobj;
53148 fail:
53149 return NULL;
53150 }
53151
53152
53153 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53154 PyObject *resultobj = 0;
53155 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53156 PyObject *arg2 = (PyObject *) 0 ;
53157 bool result;
53158 void *argp1 = 0 ;
53159 int res1 = 0 ;
53160 PyObject * obj0 = 0 ;
53161 PyObject * obj1 = 0 ;
53162 char * kwnames[] = {
53163 (char *) "self",(char *) "other", NULL
53164 };
53165
53166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53168 if (!SWIG_IsOK(res1)) {
53169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53170 }
53171 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53172 arg2 = obj1;
53173 {
53174 result = (bool)wxGBSpan___ne__(arg1,arg2);
53175 if (PyErr_Occurred()) SWIG_fail;
53176 }
53177 {
53178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53179 }
53180 return resultobj;
53181 fail:
53182 return NULL;
53183 }
53184
53185
53186 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53187 PyObject *resultobj = 0;
53188 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53189 int arg2 = (int) 1 ;
53190 int arg3 = (int) 1 ;
53191 void *argp1 = 0 ;
53192 int res1 = 0 ;
53193 int val2 ;
53194 int ecode2 = 0 ;
53195 int val3 ;
53196 int ecode3 = 0 ;
53197 PyObject * obj0 = 0 ;
53198 PyObject * obj1 = 0 ;
53199 PyObject * obj2 = 0 ;
53200 char * kwnames[] = {
53201 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53202 };
53203
53204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53206 if (!SWIG_IsOK(res1)) {
53207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53208 }
53209 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53210 if (obj1) {
53211 ecode2 = SWIG_AsVal_int(obj1, &val2);
53212 if (!SWIG_IsOK(ecode2)) {
53213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53214 }
53215 arg2 = static_cast< int >(val2);
53216 }
53217 if (obj2) {
53218 ecode3 = SWIG_AsVal_int(obj2, &val3);
53219 if (!SWIG_IsOK(ecode3)) {
53220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53221 }
53222 arg3 = static_cast< int >(val3);
53223 }
53224 {
53225 PyThreadState* __tstate = wxPyBeginAllowThreads();
53226 wxGBSpan_Set(arg1,arg2,arg3);
53227 wxPyEndAllowThreads(__tstate);
53228 if (PyErr_Occurred()) SWIG_fail;
53229 }
53230 resultobj = SWIG_Py_Void();
53231 return resultobj;
53232 fail:
53233 return NULL;
53234 }
53235
53236
53237 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53238 PyObject *resultobj = 0;
53239 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53240 PyObject *result = 0 ;
53241 void *argp1 = 0 ;
53242 int res1 = 0 ;
53243 PyObject *swig_obj[1] ;
53244
53245 if (!args) SWIG_fail;
53246 swig_obj[0] = args;
53247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53248 if (!SWIG_IsOK(res1)) {
53249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53250 }
53251 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53252 {
53253 PyThreadState* __tstate = wxPyBeginAllowThreads();
53254 result = (PyObject *)wxGBSpan_Get(arg1);
53255 wxPyEndAllowThreads(__tstate);
53256 if (PyErr_Occurred()) SWIG_fail;
53257 }
53258 resultobj = result;
53259 return resultobj;
53260 fail:
53261 return NULL;
53262 }
53263
53264
53265 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53266 PyObject *obj;
53267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53268 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53269 return SWIG_Py_Void();
53270 }
53271
53272 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53273 return SWIG_Python_InitShadowInstance(args);
53274 }
53275
53276 SWIGINTERN int DefaultSpan_set(PyObject *) {
53277 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53278 return 1;
53279 }
53280
53281
53282 SWIGINTERN PyObject *DefaultSpan_get(void) {
53283 PyObject *pyobj = 0;
53284
53285 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53286 return pyobj;
53287 }
53288
53289
53290 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53291 PyObject *resultobj = 0;
53292 wxGBSizerItem *result = 0 ;
53293
53294 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53295 {
53296 PyThreadState* __tstate = wxPyBeginAllowThreads();
53297 result = (wxGBSizerItem *)new wxGBSizerItem();
53298 wxPyEndAllowThreads(__tstate);
53299 if (PyErr_Occurred()) SWIG_fail;
53300 }
53301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53302 return resultobj;
53303 fail:
53304 return NULL;
53305 }
53306
53307
53308 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53309 PyObject *resultobj = 0;
53310 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53311 void *argp1 = 0 ;
53312 int res1 = 0 ;
53313 PyObject *swig_obj[1] ;
53314
53315 if (!args) SWIG_fail;
53316 swig_obj[0] = args;
53317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53318 if (!SWIG_IsOK(res1)) {
53319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53320 }
53321 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53322 {
53323 PyThreadState* __tstate = wxPyBeginAllowThreads();
53324 delete arg1;
53325
53326 wxPyEndAllowThreads(__tstate);
53327 if (PyErr_Occurred()) SWIG_fail;
53328 }
53329 resultobj = SWIG_Py_Void();
53330 return resultobj;
53331 fail:
53332 return NULL;
53333 }
53334
53335
53336 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53337 PyObject *resultobj = 0;
53338 wxWindow *arg1 = (wxWindow *) 0 ;
53339 wxGBPosition *arg2 = 0 ;
53340 wxGBSpan *arg3 = 0 ;
53341 int arg4 ;
53342 int arg5 ;
53343 PyObject *arg6 = (PyObject *) NULL ;
53344 wxGBSizerItem *result = 0 ;
53345 void *argp1 = 0 ;
53346 int res1 = 0 ;
53347 wxGBPosition temp2 ;
53348 wxGBSpan temp3 ;
53349 int val4 ;
53350 int ecode4 = 0 ;
53351 int val5 ;
53352 int ecode5 = 0 ;
53353 PyObject * obj0 = 0 ;
53354 PyObject * obj1 = 0 ;
53355 PyObject * obj2 = 0 ;
53356 PyObject * obj3 = 0 ;
53357 PyObject * obj4 = 0 ;
53358 PyObject * obj5 = 0 ;
53359 char * kwnames[] = {
53360 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53361 };
53362
53363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53365 if (!SWIG_IsOK(res1)) {
53366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53367 }
53368 arg1 = reinterpret_cast< wxWindow * >(argp1);
53369 {
53370 arg2 = &temp2;
53371 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53372 }
53373 {
53374 arg3 = &temp3;
53375 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53376 }
53377 ecode4 = SWIG_AsVal_int(obj3, &val4);
53378 if (!SWIG_IsOK(ecode4)) {
53379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53380 }
53381 arg4 = static_cast< int >(val4);
53382 ecode5 = SWIG_AsVal_int(obj4, &val5);
53383 if (!SWIG_IsOK(ecode5)) {
53384 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53385 }
53386 arg5 = static_cast< int >(val5);
53387 if (obj5) {
53388 arg6 = obj5;
53389 }
53390 {
53391 PyThreadState* __tstate = wxPyBeginAllowThreads();
53392 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53393 wxPyEndAllowThreads(__tstate);
53394 if (PyErr_Occurred()) SWIG_fail;
53395 }
53396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53397 return resultobj;
53398 fail:
53399 return NULL;
53400 }
53401
53402
53403 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53404 PyObject *resultobj = 0;
53405 wxSizer *arg1 = (wxSizer *) 0 ;
53406 wxGBPosition *arg2 = 0 ;
53407 wxGBSpan *arg3 = 0 ;
53408 int arg4 ;
53409 int arg5 ;
53410 PyObject *arg6 = (PyObject *) NULL ;
53411 wxGBSizerItem *result = 0 ;
53412 int res1 = 0 ;
53413 wxGBPosition temp2 ;
53414 wxGBSpan temp3 ;
53415 int val4 ;
53416 int ecode4 = 0 ;
53417 int val5 ;
53418 int ecode5 = 0 ;
53419 PyObject * obj0 = 0 ;
53420 PyObject * obj1 = 0 ;
53421 PyObject * obj2 = 0 ;
53422 PyObject * obj3 = 0 ;
53423 PyObject * obj4 = 0 ;
53424 PyObject * obj5 = 0 ;
53425 char * kwnames[] = {
53426 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53427 };
53428
53429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53430 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53431 if (!SWIG_IsOK(res1)) {
53432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53433 }
53434 {
53435 arg2 = &temp2;
53436 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53437 }
53438 {
53439 arg3 = &temp3;
53440 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53441 }
53442 ecode4 = SWIG_AsVal_int(obj3, &val4);
53443 if (!SWIG_IsOK(ecode4)) {
53444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53445 }
53446 arg4 = static_cast< int >(val4);
53447 ecode5 = SWIG_AsVal_int(obj4, &val5);
53448 if (!SWIG_IsOK(ecode5)) {
53449 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53450 }
53451 arg5 = static_cast< int >(val5);
53452 if (obj5) {
53453 arg6 = obj5;
53454 }
53455 {
53456 PyThreadState* __tstate = wxPyBeginAllowThreads();
53457 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53458 wxPyEndAllowThreads(__tstate);
53459 if (PyErr_Occurred()) SWIG_fail;
53460 }
53461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53462 return resultobj;
53463 fail:
53464 return NULL;
53465 }
53466
53467
53468 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53469 PyObject *resultobj = 0;
53470 int arg1 ;
53471 int arg2 ;
53472 wxGBPosition *arg3 = 0 ;
53473 wxGBSpan *arg4 = 0 ;
53474 int arg5 ;
53475 int arg6 ;
53476 PyObject *arg7 = (PyObject *) NULL ;
53477 wxGBSizerItem *result = 0 ;
53478 int val1 ;
53479 int ecode1 = 0 ;
53480 int val2 ;
53481 int ecode2 = 0 ;
53482 wxGBPosition temp3 ;
53483 wxGBSpan temp4 ;
53484 int val5 ;
53485 int ecode5 = 0 ;
53486 int val6 ;
53487 int ecode6 = 0 ;
53488 PyObject * obj0 = 0 ;
53489 PyObject * obj1 = 0 ;
53490 PyObject * obj2 = 0 ;
53491 PyObject * obj3 = 0 ;
53492 PyObject * obj4 = 0 ;
53493 PyObject * obj5 = 0 ;
53494 PyObject * obj6 = 0 ;
53495 char * kwnames[] = {
53496 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53497 };
53498
53499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53500 ecode1 = SWIG_AsVal_int(obj0, &val1);
53501 if (!SWIG_IsOK(ecode1)) {
53502 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53503 }
53504 arg1 = static_cast< int >(val1);
53505 ecode2 = SWIG_AsVal_int(obj1, &val2);
53506 if (!SWIG_IsOK(ecode2)) {
53507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53508 }
53509 arg2 = static_cast< int >(val2);
53510 {
53511 arg3 = &temp3;
53512 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53513 }
53514 {
53515 arg4 = &temp4;
53516 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53517 }
53518 ecode5 = SWIG_AsVal_int(obj4, &val5);
53519 if (!SWIG_IsOK(ecode5)) {
53520 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53521 }
53522 arg5 = static_cast< int >(val5);
53523 ecode6 = SWIG_AsVal_int(obj5, &val6);
53524 if (!SWIG_IsOK(ecode6)) {
53525 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53526 }
53527 arg6 = static_cast< int >(val6);
53528 if (obj6) {
53529 arg7 = obj6;
53530 }
53531 {
53532 PyThreadState* __tstate = wxPyBeginAllowThreads();
53533 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53534 wxPyEndAllowThreads(__tstate);
53535 if (PyErr_Occurred()) SWIG_fail;
53536 }
53537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53538 return resultobj;
53539 fail:
53540 return NULL;
53541 }
53542
53543
53544 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53545 PyObject *resultobj = 0;
53546 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53547 wxGBPosition result;
53548 void *argp1 = 0 ;
53549 int res1 = 0 ;
53550 PyObject *swig_obj[1] ;
53551
53552 if (!args) SWIG_fail;
53553 swig_obj[0] = args;
53554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53555 if (!SWIG_IsOK(res1)) {
53556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53557 }
53558 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53559 {
53560 PyThreadState* __tstate = wxPyBeginAllowThreads();
53561 result = ((wxGBSizerItem const *)arg1)->GetPos();
53562 wxPyEndAllowThreads(__tstate);
53563 if (PyErr_Occurred()) SWIG_fail;
53564 }
53565 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53566 return resultobj;
53567 fail:
53568 return NULL;
53569 }
53570
53571
53572 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53573 PyObject *resultobj = 0;
53574 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53575 wxGBSpan result;
53576 void *argp1 = 0 ;
53577 int res1 = 0 ;
53578 PyObject *swig_obj[1] ;
53579
53580 if (!args) SWIG_fail;
53581 swig_obj[0] = args;
53582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53583 if (!SWIG_IsOK(res1)) {
53584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53585 }
53586 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53587 {
53588 PyThreadState* __tstate = wxPyBeginAllowThreads();
53589 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53590 wxPyEndAllowThreads(__tstate);
53591 if (PyErr_Occurred()) SWIG_fail;
53592 }
53593 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53594 return resultobj;
53595 fail:
53596 return NULL;
53597 }
53598
53599
53600 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53601 PyObject *resultobj = 0;
53602 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53603 wxGBPosition *arg2 = 0 ;
53604 bool result;
53605 void *argp1 = 0 ;
53606 int res1 = 0 ;
53607 wxGBPosition temp2 ;
53608 PyObject * obj0 = 0 ;
53609 PyObject * obj1 = 0 ;
53610 char * kwnames[] = {
53611 (char *) "self",(char *) "pos", NULL
53612 };
53613
53614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53616 if (!SWIG_IsOK(res1)) {
53617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53618 }
53619 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53620 {
53621 arg2 = &temp2;
53622 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53623 }
53624 {
53625 PyThreadState* __tstate = wxPyBeginAllowThreads();
53626 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53627 wxPyEndAllowThreads(__tstate);
53628 if (PyErr_Occurred()) SWIG_fail;
53629 }
53630 {
53631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53632 }
53633 return resultobj;
53634 fail:
53635 return NULL;
53636 }
53637
53638
53639 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53640 PyObject *resultobj = 0;
53641 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53642 wxGBSpan *arg2 = 0 ;
53643 bool result;
53644 void *argp1 = 0 ;
53645 int res1 = 0 ;
53646 wxGBSpan temp2 ;
53647 PyObject * obj0 = 0 ;
53648 PyObject * obj1 = 0 ;
53649 char * kwnames[] = {
53650 (char *) "self",(char *) "span", NULL
53651 };
53652
53653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53655 if (!SWIG_IsOK(res1)) {
53656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53657 }
53658 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53659 {
53660 arg2 = &temp2;
53661 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53662 }
53663 {
53664 PyThreadState* __tstate = wxPyBeginAllowThreads();
53665 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53666 wxPyEndAllowThreads(__tstate);
53667 if (PyErr_Occurred()) SWIG_fail;
53668 }
53669 {
53670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53671 }
53672 return resultobj;
53673 fail:
53674 return NULL;
53675 }
53676
53677
53678 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53679 PyObject *resultobj = 0;
53680 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53681 wxGBSizerItem *arg2 = 0 ;
53682 bool result;
53683 void *argp1 = 0 ;
53684 int res1 = 0 ;
53685 void *argp2 = 0 ;
53686 int res2 = 0 ;
53687 PyObject * obj0 = 0 ;
53688 PyObject * obj1 = 0 ;
53689 char * kwnames[] = {
53690 (char *) "self",(char *) "other", NULL
53691 };
53692
53693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53695 if (!SWIG_IsOK(res1)) {
53696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53697 }
53698 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53699 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53700 if (!SWIG_IsOK(res2)) {
53701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53702 }
53703 if (!argp2) {
53704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53705 }
53706 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53707 {
53708 PyThreadState* __tstate = wxPyBeginAllowThreads();
53709 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53710 wxPyEndAllowThreads(__tstate);
53711 if (PyErr_Occurred()) SWIG_fail;
53712 }
53713 {
53714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53715 }
53716 return resultobj;
53717 fail:
53718 return NULL;
53719 }
53720
53721
53722 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53723 PyObject *resultobj = 0;
53724 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53725 wxGBPosition *arg2 = 0 ;
53726 wxGBSpan *arg3 = 0 ;
53727 bool result;
53728 void *argp1 = 0 ;
53729 int res1 = 0 ;
53730 wxGBPosition temp2 ;
53731 wxGBSpan temp3 ;
53732 PyObject * obj0 = 0 ;
53733 PyObject * obj1 = 0 ;
53734 PyObject * obj2 = 0 ;
53735 char * kwnames[] = {
53736 (char *) "self",(char *) "pos",(char *) "span", NULL
53737 };
53738
53739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53741 if (!SWIG_IsOK(res1)) {
53742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53743 }
53744 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53745 {
53746 arg2 = &temp2;
53747 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53748 }
53749 {
53750 arg3 = &temp3;
53751 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53752 }
53753 {
53754 PyThreadState* __tstate = wxPyBeginAllowThreads();
53755 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53756 wxPyEndAllowThreads(__tstate);
53757 if (PyErr_Occurred()) SWIG_fail;
53758 }
53759 {
53760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53761 }
53762 return resultobj;
53763 fail:
53764 return NULL;
53765 }
53766
53767
53768 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53769 PyObject *resultobj = 0;
53770 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53771 wxGBPosition result;
53772 void *argp1 = 0 ;
53773 int res1 = 0 ;
53774 PyObject *swig_obj[1] ;
53775
53776 if (!args) SWIG_fail;
53777 swig_obj[0] = args;
53778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53779 if (!SWIG_IsOK(res1)) {
53780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53781 }
53782 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53783 {
53784 PyThreadState* __tstate = wxPyBeginAllowThreads();
53785 result = wxGBSizerItem_GetEndPos(arg1);
53786 wxPyEndAllowThreads(__tstate);
53787 if (PyErr_Occurred()) SWIG_fail;
53788 }
53789 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53790 return resultobj;
53791 fail:
53792 return NULL;
53793 }
53794
53795
53796 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53797 PyObject *resultobj = 0;
53798 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53799 wxGridBagSizer *result = 0 ;
53800 void *argp1 = 0 ;
53801 int res1 = 0 ;
53802 PyObject *swig_obj[1] ;
53803
53804 if (!args) SWIG_fail;
53805 swig_obj[0] = args;
53806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53807 if (!SWIG_IsOK(res1)) {
53808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53809 }
53810 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53811 {
53812 PyThreadState* __tstate = wxPyBeginAllowThreads();
53813 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53814 wxPyEndAllowThreads(__tstate);
53815 if (PyErr_Occurred()) SWIG_fail;
53816 }
53817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53818 return resultobj;
53819 fail:
53820 return NULL;
53821 }
53822
53823
53824 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53825 PyObject *resultobj = 0;
53826 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53827 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53828 void *argp1 = 0 ;
53829 int res1 = 0 ;
53830 void *argp2 = 0 ;
53831 int res2 = 0 ;
53832 PyObject * obj0 = 0 ;
53833 PyObject * obj1 = 0 ;
53834 char * kwnames[] = {
53835 (char *) "self",(char *) "sizer", NULL
53836 };
53837
53838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53840 if (!SWIG_IsOK(res1)) {
53841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53842 }
53843 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53844 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53845 if (!SWIG_IsOK(res2)) {
53846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53847 }
53848 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53849 {
53850 PyThreadState* __tstate = wxPyBeginAllowThreads();
53851 (arg1)->SetGBSizer(arg2);
53852 wxPyEndAllowThreads(__tstate);
53853 if (PyErr_Occurred()) SWIG_fail;
53854 }
53855 resultobj = SWIG_Py_Void();
53856 return resultobj;
53857 fail:
53858 return NULL;
53859 }
53860
53861
53862 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53863 PyObject *obj;
53864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53865 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53866 return SWIG_Py_Void();
53867 }
53868
53869 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53870 return SWIG_Python_InitShadowInstance(args);
53871 }
53872
53873 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53874 PyObject *resultobj = 0;
53875 int arg1 = (int) 0 ;
53876 int arg2 = (int) 0 ;
53877 wxGridBagSizer *result = 0 ;
53878 int val1 ;
53879 int ecode1 = 0 ;
53880 int val2 ;
53881 int ecode2 = 0 ;
53882 PyObject * obj0 = 0 ;
53883 PyObject * obj1 = 0 ;
53884 char * kwnames[] = {
53885 (char *) "vgap",(char *) "hgap", NULL
53886 };
53887
53888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53889 if (obj0) {
53890 ecode1 = SWIG_AsVal_int(obj0, &val1);
53891 if (!SWIG_IsOK(ecode1)) {
53892 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53893 }
53894 arg1 = static_cast< int >(val1);
53895 }
53896 if (obj1) {
53897 ecode2 = SWIG_AsVal_int(obj1, &val2);
53898 if (!SWIG_IsOK(ecode2)) {
53899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53900 }
53901 arg2 = static_cast< int >(val2);
53902 }
53903 {
53904 PyThreadState* __tstate = wxPyBeginAllowThreads();
53905 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53906 wxPyEndAllowThreads(__tstate);
53907 if (PyErr_Occurred()) SWIG_fail;
53908 }
53909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53910 return resultobj;
53911 fail:
53912 return NULL;
53913 }
53914
53915
53916 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53917 PyObject *resultobj = 0;
53918 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53919 PyObject *arg2 = (PyObject *) 0 ;
53920 wxGBPosition *arg3 = 0 ;
53921 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53922 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53923 int arg5 = (int) 0 ;
53924 int arg6 = (int) 0 ;
53925 PyObject *arg7 = (PyObject *) NULL ;
53926 wxGBSizerItem *result = 0 ;
53927 void *argp1 = 0 ;
53928 int res1 = 0 ;
53929 wxGBPosition temp3 ;
53930 wxGBSpan temp4 ;
53931 int val5 ;
53932 int ecode5 = 0 ;
53933 int val6 ;
53934 int ecode6 = 0 ;
53935 PyObject * obj0 = 0 ;
53936 PyObject * obj1 = 0 ;
53937 PyObject * obj2 = 0 ;
53938 PyObject * obj3 = 0 ;
53939 PyObject * obj4 = 0 ;
53940 PyObject * obj5 = 0 ;
53941 PyObject * obj6 = 0 ;
53942 char * kwnames[] = {
53943 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53944 };
53945
53946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53948 if (!SWIG_IsOK(res1)) {
53949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53950 }
53951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53952 arg2 = obj1;
53953 {
53954 arg3 = &temp3;
53955 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53956 }
53957 if (obj3) {
53958 {
53959 arg4 = &temp4;
53960 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53961 }
53962 }
53963 if (obj4) {
53964 ecode5 = SWIG_AsVal_int(obj4, &val5);
53965 if (!SWIG_IsOK(ecode5)) {
53966 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53967 }
53968 arg5 = static_cast< int >(val5);
53969 }
53970 if (obj5) {
53971 ecode6 = SWIG_AsVal_int(obj5, &val6);
53972 if (!SWIG_IsOK(ecode6)) {
53973 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53974 }
53975 arg6 = static_cast< int >(val6);
53976 }
53977 if (obj6) {
53978 arg7 = obj6;
53979 }
53980 {
53981 PyThreadState* __tstate = wxPyBeginAllowThreads();
53982 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53983 wxPyEndAllowThreads(__tstate);
53984 if (PyErr_Occurred()) SWIG_fail;
53985 }
53986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53987 return resultobj;
53988 fail:
53989 return NULL;
53990 }
53991
53992
53993 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53994 PyObject *resultobj = 0;
53995 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53996 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53997 wxGBSizerItem *result = 0 ;
53998 void *argp1 = 0 ;
53999 int res1 = 0 ;
54000 int res2 = 0 ;
54001 PyObject * obj0 = 0 ;
54002 PyObject * obj1 = 0 ;
54003 char * kwnames[] = {
54004 (char *) "self",(char *) "item", NULL
54005 };
54006
54007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54009 if (!SWIG_IsOK(res1)) {
54010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54011 }
54012 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54013 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54014 if (!SWIG_IsOK(res2)) {
54015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54016 }
54017 {
54018 PyThreadState* __tstate = wxPyBeginAllowThreads();
54019 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54020 wxPyEndAllowThreads(__tstate);
54021 if (PyErr_Occurred()) SWIG_fail;
54022 }
54023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54024 return resultobj;
54025 fail:
54026 return NULL;
54027 }
54028
54029
54030 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54031 PyObject *resultobj = 0;
54032 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54033 int arg2 ;
54034 int arg3 ;
54035 wxSize result;
54036 void *argp1 = 0 ;
54037 int res1 = 0 ;
54038 int val2 ;
54039 int ecode2 = 0 ;
54040 int val3 ;
54041 int ecode3 = 0 ;
54042 PyObject * obj0 = 0 ;
54043 PyObject * obj1 = 0 ;
54044 PyObject * obj2 = 0 ;
54045 char * kwnames[] = {
54046 (char *) "self",(char *) "row",(char *) "col", NULL
54047 };
54048
54049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54051 if (!SWIG_IsOK(res1)) {
54052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54053 }
54054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54055 ecode2 = SWIG_AsVal_int(obj1, &val2);
54056 if (!SWIG_IsOK(ecode2)) {
54057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54058 }
54059 arg2 = static_cast< int >(val2);
54060 ecode3 = SWIG_AsVal_int(obj2, &val3);
54061 if (!SWIG_IsOK(ecode3)) {
54062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54063 }
54064 arg3 = static_cast< int >(val3);
54065 {
54066 PyThreadState* __tstate = wxPyBeginAllowThreads();
54067 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54068 wxPyEndAllowThreads(__tstate);
54069 if (PyErr_Occurred()) SWIG_fail;
54070 }
54071 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54072 return resultobj;
54073 fail:
54074 return NULL;
54075 }
54076
54077
54078 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54079 PyObject *resultobj = 0;
54080 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54081 wxSize result;
54082 void *argp1 = 0 ;
54083 int res1 = 0 ;
54084 PyObject *swig_obj[1] ;
54085
54086 if (!args) SWIG_fail;
54087 swig_obj[0] = args;
54088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54089 if (!SWIG_IsOK(res1)) {
54090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54091 }
54092 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54093 {
54094 PyThreadState* __tstate = wxPyBeginAllowThreads();
54095 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54096 wxPyEndAllowThreads(__tstate);
54097 if (PyErr_Occurred()) SWIG_fail;
54098 }
54099 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54100 return resultobj;
54101 fail:
54102 return NULL;
54103 }
54104
54105
54106 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54107 PyObject *resultobj = 0;
54108 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54109 wxSize *arg2 = 0 ;
54110 void *argp1 = 0 ;
54111 int res1 = 0 ;
54112 wxSize temp2 ;
54113 PyObject * obj0 = 0 ;
54114 PyObject * obj1 = 0 ;
54115 char * kwnames[] = {
54116 (char *) "self",(char *) "sz", NULL
54117 };
54118
54119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54121 if (!SWIG_IsOK(res1)) {
54122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54123 }
54124 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54125 {
54126 arg2 = &temp2;
54127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54128 }
54129 {
54130 PyThreadState* __tstate = wxPyBeginAllowThreads();
54131 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54132 wxPyEndAllowThreads(__tstate);
54133 if (PyErr_Occurred()) SWIG_fail;
54134 }
54135 resultobj = SWIG_Py_Void();
54136 return resultobj;
54137 fail:
54138 return NULL;
54139 }
54140
54141
54142 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54143 PyObject *resultobj = 0;
54144 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54145 wxWindow *arg2 = (wxWindow *) 0 ;
54146 wxGBPosition result;
54147 void *argp1 = 0 ;
54148 int res1 = 0 ;
54149 void *argp2 = 0 ;
54150 int res2 = 0 ;
54151
54152 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54154 if (!SWIG_IsOK(res1)) {
54155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54156 }
54157 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54158 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54159 if (!SWIG_IsOK(res2)) {
54160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54161 }
54162 arg2 = reinterpret_cast< wxWindow * >(argp2);
54163 {
54164 PyThreadState* __tstate = wxPyBeginAllowThreads();
54165 result = (arg1)->GetItemPosition(arg2);
54166 wxPyEndAllowThreads(__tstate);
54167 if (PyErr_Occurred()) SWIG_fail;
54168 }
54169 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54170 return resultobj;
54171 fail:
54172 return NULL;
54173 }
54174
54175
54176 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54177 PyObject *resultobj = 0;
54178 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54179 wxSizer *arg2 = (wxSizer *) 0 ;
54180 wxGBPosition result;
54181 void *argp1 = 0 ;
54182 int res1 = 0 ;
54183 void *argp2 = 0 ;
54184 int res2 = 0 ;
54185
54186 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54188 if (!SWIG_IsOK(res1)) {
54189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54190 }
54191 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54192 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54193 if (!SWIG_IsOK(res2)) {
54194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54195 }
54196 arg2 = reinterpret_cast< wxSizer * >(argp2);
54197 {
54198 PyThreadState* __tstate = wxPyBeginAllowThreads();
54199 result = (arg1)->GetItemPosition(arg2);
54200 wxPyEndAllowThreads(__tstate);
54201 if (PyErr_Occurred()) SWIG_fail;
54202 }
54203 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54204 return resultobj;
54205 fail:
54206 return NULL;
54207 }
54208
54209
54210 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54211 PyObject *resultobj = 0;
54212 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54213 size_t arg2 ;
54214 wxGBPosition result;
54215 void *argp1 = 0 ;
54216 int res1 = 0 ;
54217 size_t val2 ;
54218 int ecode2 = 0 ;
54219
54220 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54222 if (!SWIG_IsOK(res1)) {
54223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54224 }
54225 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54226 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54227 if (!SWIG_IsOK(ecode2)) {
54228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54229 }
54230 arg2 = static_cast< size_t >(val2);
54231 {
54232 PyThreadState* __tstate = wxPyBeginAllowThreads();
54233 result = (arg1)->GetItemPosition(arg2);
54234 wxPyEndAllowThreads(__tstate);
54235 if (PyErr_Occurred()) SWIG_fail;
54236 }
54237 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54238 return resultobj;
54239 fail:
54240 return NULL;
54241 }
54242
54243
54244 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54245 int argc;
54246 PyObject *argv[3];
54247
54248 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54249 --argc;
54250 if (argc == 2) {
54251 int _v = 0;
54252 {
54253 void *vptr = 0;
54254 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54255 _v = SWIG_CheckState(res);
54256 }
54257 if (!_v) goto check_1;
54258 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54259 }
54260 check_1:
54261
54262 if (argc == 2) {
54263 int _v = 0;
54264 {
54265 void *vptr = 0;
54266 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54267 _v = SWIG_CheckState(res);
54268 }
54269 if (!_v) goto check_2;
54270 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54271 }
54272 check_2:
54273
54274 if (argc == 2) {
54275 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54276 }
54277
54278 fail:
54279 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54280 return NULL;
54281 }
54282
54283
54284 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54285 PyObject *resultobj = 0;
54286 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54287 wxWindow *arg2 = (wxWindow *) 0 ;
54288 wxGBPosition *arg3 = 0 ;
54289 bool result;
54290 void *argp1 = 0 ;
54291 int res1 = 0 ;
54292 void *argp2 = 0 ;
54293 int res2 = 0 ;
54294 wxGBPosition temp3 ;
54295
54296 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54298 if (!SWIG_IsOK(res1)) {
54299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54300 }
54301 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54302 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54303 if (!SWIG_IsOK(res2)) {
54304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54305 }
54306 arg2 = reinterpret_cast< wxWindow * >(argp2);
54307 {
54308 arg3 = &temp3;
54309 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54310 }
54311 {
54312 PyThreadState* __tstate = wxPyBeginAllowThreads();
54313 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54314 wxPyEndAllowThreads(__tstate);
54315 if (PyErr_Occurred()) SWIG_fail;
54316 }
54317 {
54318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54319 }
54320 return resultobj;
54321 fail:
54322 return NULL;
54323 }
54324
54325
54326 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54327 PyObject *resultobj = 0;
54328 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54329 wxSizer *arg2 = (wxSizer *) 0 ;
54330 wxGBPosition *arg3 = 0 ;
54331 bool result;
54332 void *argp1 = 0 ;
54333 int res1 = 0 ;
54334 void *argp2 = 0 ;
54335 int res2 = 0 ;
54336 wxGBPosition temp3 ;
54337
54338 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54340 if (!SWIG_IsOK(res1)) {
54341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54342 }
54343 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54344 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54345 if (!SWIG_IsOK(res2)) {
54346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54347 }
54348 arg2 = reinterpret_cast< wxSizer * >(argp2);
54349 {
54350 arg3 = &temp3;
54351 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54352 }
54353 {
54354 PyThreadState* __tstate = wxPyBeginAllowThreads();
54355 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54356 wxPyEndAllowThreads(__tstate);
54357 if (PyErr_Occurred()) SWIG_fail;
54358 }
54359 {
54360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54361 }
54362 return resultobj;
54363 fail:
54364 return NULL;
54365 }
54366
54367
54368 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54369 PyObject *resultobj = 0;
54370 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54371 size_t arg2 ;
54372 wxGBPosition *arg3 = 0 ;
54373 bool result;
54374 void *argp1 = 0 ;
54375 int res1 = 0 ;
54376 size_t val2 ;
54377 int ecode2 = 0 ;
54378 wxGBPosition temp3 ;
54379
54380 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54382 if (!SWIG_IsOK(res1)) {
54383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54384 }
54385 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54386 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54387 if (!SWIG_IsOK(ecode2)) {
54388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54389 }
54390 arg2 = static_cast< size_t >(val2);
54391 {
54392 arg3 = &temp3;
54393 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54394 }
54395 {
54396 PyThreadState* __tstate = wxPyBeginAllowThreads();
54397 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54398 wxPyEndAllowThreads(__tstate);
54399 if (PyErr_Occurred()) SWIG_fail;
54400 }
54401 {
54402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54403 }
54404 return resultobj;
54405 fail:
54406 return NULL;
54407 }
54408
54409
54410 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54411 int argc;
54412 PyObject *argv[4];
54413
54414 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54415 --argc;
54416 if (argc == 3) {
54417 int _v = 0;
54418 {
54419 void *vptr = 0;
54420 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54421 _v = SWIG_CheckState(res);
54422 }
54423 if (!_v) goto check_1;
54424 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54425 }
54426 check_1:
54427
54428 if (argc == 3) {
54429 int _v = 0;
54430 {
54431 void *vptr = 0;
54432 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54433 _v = SWIG_CheckState(res);
54434 }
54435 if (!_v) goto check_2;
54436 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54437 }
54438 check_2:
54439
54440 if (argc == 3) {
54441 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54442 }
54443
54444 fail:
54445 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54446 return NULL;
54447 }
54448
54449
54450 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54451 PyObject *resultobj = 0;
54452 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54453 wxWindow *arg2 = (wxWindow *) 0 ;
54454 wxGBSpan result;
54455 void *argp1 = 0 ;
54456 int res1 = 0 ;
54457 void *argp2 = 0 ;
54458 int res2 = 0 ;
54459
54460 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54462 if (!SWIG_IsOK(res1)) {
54463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54464 }
54465 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54466 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54467 if (!SWIG_IsOK(res2)) {
54468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54469 }
54470 arg2 = reinterpret_cast< wxWindow * >(argp2);
54471 {
54472 PyThreadState* __tstate = wxPyBeginAllowThreads();
54473 result = (arg1)->GetItemSpan(arg2);
54474 wxPyEndAllowThreads(__tstate);
54475 if (PyErr_Occurred()) SWIG_fail;
54476 }
54477 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54478 return resultobj;
54479 fail:
54480 return NULL;
54481 }
54482
54483
54484 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54485 PyObject *resultobj = 0;
54486 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54487 wxSizer *arg2 = (wxSizer *) 0 ;
54488 wxGBSpan result;
54489 void *argp1 = 0 ;
54490 int res1 = 0 ;
54491 void *argp2 = 0 ;
54492 int res2 = 0 ;
54493
54494 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54496 if (!SWIG_IsOK(res1)) {
54497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54498 }
54499 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54500 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54501 if (!SWIG_IsOK(res2)) {
54502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54503 }
54504 arg2 = reinterpret_cast< wxSizer * >(argp2);
54505 {
54506 PyThreadState* __tstate = wxPyBeginAllowThreads();
54507 result = (arg1)->GetItemSpan(arg2);
54508 wxPyEndAllowThreads(__tstate);
54509 if (PyErr_Occurred()) SWIG_fail;
54510 }
54511 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54512 return resultobj;
54513 fail:
54514 return NULL;
54515 }
54516
54517
54518 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54519 PyObject *resultobj = 0;
54520 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54521 size_t arg2 ;
54522 wxGBSpan result;
54523 void *argp1 = 0 ;
54524 int res1 = 0 ;
54525 size_t val2 ;
54526 int ecode2 = 0 ;
54527
54528 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54530 if (!SWIG_IsOK(res1)) {
54531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54532 }
54533 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54534 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54535 if (!SWIG_IsOK(ecode2)) {
54536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54537 }
54538 arg2 = static_cast< size_t >(val2);
54539 {
54540 PyThreadState* __tstate = wxPyBeginAllowThreads();
54541 result = (arg1)->GetItemSpan(arg2);
54542 wxPyEndAllowThreads(__tstate);
54543 if (PyErr_Occurred()) SWIG_fail;
54544 }
54545 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54546 return resultobj;
54547 fail:
54548 return NULL;
54549 }
54550
54551
54552 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54553 int argc;
54554 PyObject *argv[3];
54555
54556 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54557 --argc;
54558 if (argc == 2) {
54559 int _v = 0;
54560 {
54561 void *vptr = 0;
54562 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54563 _v = SWIG_CheckState(res);
54564 }
54565 if (!_v) goto check_1;
54566 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54567 }
54568 check_1:
54569
54570 if (argc == 2) {
54571 int _v = 0;
54572 {
54573 void *vptr = 0;
54574 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54575 _v = SWIG_CheckState(res);
54576 }
54577 if (!_v) goto check_2;
54578 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54579 }
54580 check_2:
54581
54582 if (argc == 2) {
54583 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54584 }
54585
54586 fail:
54587 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54588 return NULL;
54589 }
54590
54591
54592 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54593 PyObject *resultobj = 0;
54594 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54595 wxWindow *arg2 = (wxWindow *) 0 ;
54596 wxGBSpan *arg3 = 0 ;
54597 bool result;
54598 void *argp1 = 0 ;
54599 int res1 = 0 ;
54600 void *argp2 = 0 ;
54601 int res2 = 0 ;
54602 wxGBSpan temp3 ;
54603
54604 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54606 if (!SWIG_IsOK(res1)) {
54607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54608 }
54609 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54610 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54611 if (!SWIG_IsOK(res2)) {
54612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54613 }
54614 arg2 = reinterpret_cast< wxWindow * >(argp2);
54615 {
54616 arg3 = &temp3;
54617 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54618 }
54619 {
54620 PyThreadState* __tstate = wxPyBeginAllowThreads();
54621 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54622 wxPyEndAllowThreads(__tstate);
54623 if (PyErr_Occurred()) SWIG_fail;
54624 }
54625 {
54626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54627 }
54628 return resultobj;
54629 fail:
54630 return NULL;
54631 }
54632
54633
54634 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54635 PyObject *resultobj = 0;
54636 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54637 wxSizer *arg2 = (wxSizer *) 0 ;
54638 wxGBSpan *arg3 = 0 ;
54639 bool result;
54640 void *argp1 = 0 ;
54641 int res1 = 0 ;
54642 void *argp2 = 0 ;
54643 int res2 = 0 ;
54644 wxGBSpan temp3 ;
54645
54646 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54648 if (!SWIG_IsOK(res1)) {
54649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54650 }
54651 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54652 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54653 if (!SWIG_IsOK(res2)) {
54654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54655 }
54656 arg2 = reinterpret_cast< wxSizer * >(argp2);
54657 {
54658 arg3 = &temp3;
54659 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54660 }
54661 {
54662 PyThreadState* __tstate = wxPyBeginAllowThreads();
54663 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54664 wxPyEndAllowThreads(__tstate);
54665 if (PyErr_Occurred()) SWIG_fail;
54666 }
54667 {
54668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54669 }
54670 return resultobj;
54671 fail:
54672 return NULL;
54673 }
54674
54675
54676 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54677 PyObject *resultobj = 0;
54678 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54679 size_t arg2 ;
54680 wxGBSpan *arg3 = 0 ;
54681 bool result;
54682 void *argp1 = 0 ;
54683 int res1 = 0 ;
54684 size_t val2 ;
54685 int ecode2 = 0 ;
54686 wxGBSpan temp3 ;
54687
54688 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54690 if (!SWIG_IsOK(res1)) {
54691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54692 }
54693 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54694 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54695 if (!SWIG_IsOK(ecode2)) {
54696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54697 }
54698 arg2 = static_cast< size_t >(val2);
54699 {
54700 arg3 = &temp3;
54701 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54702 }
54703 {
54704 PyThreadState* __tstate = wxPyBeginAllowThreads();
54705 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54706 wxPyEndAllowThreads(__tstate);
54707 if (PyErr_Occurred()) SWIG_fail;
54708 }
54709 {
54710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54711 }
54712 return resultobj;
54713 fail:
54714 return NULL;
54715 }
54716
54717
54718 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54719 int argc;
54720 PyObject *argv[4];
54721
54722 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54723 --argc;
54724 if (argc == 3) {
54725 int _v = 0;
54726 {
54727 void *vptr = 0;
54728 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54729 _v = SWIG_CheckState(res);
54730 }
54731 if (!_v) goto check_1;
54732 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54733 }
54734 check_1:
54735
54736 if (argc == 3) {
54737 int _v = 0;
54738 {
54739 void *vptr = 0;
54740 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54741 _v = SWIG_CheckState(res);
54742 }
54743 if (!_v) goto check_2;
54744 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54745 }
54746 check_2:
54747
54748 if (argc == 3) {
54749 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54750 }
54751
54752 fail:
54753 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54754 return NULL;
54755 }
54756
54757
54758 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54759 PyObject *resultobj = 0;
54760 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54761 wxWindow *arg2 = (wxWindow *) 0 ;
54762 wxGBSizerItem *result = 0 ;
54763 void *argp1 = 0 ;
54764 int res1 = 0 ;
54765 void *argp2 = 0 ;
54766 int res2 = 0 ;
54767
54768 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54770 if (!SWIG_IsOK(res1)) {
54771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54772 }
54773 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54774 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54775 if (!SWIG_IsOK(res2)) {
54776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54777 }
54778 arg2 = reinterpret_cast< wxWindow * >(argp2);
54779 {
54780 PyThreadState* __tstate = wxPyBeginAllowThreads();
54781 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54782 wxPyEndAllowThreads(__tstate);
54783 if (PyErr_Occurred()) SWIG_fail;
54784 }
54785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54786 return resultobj;
54787 fail:
54788 return NULL;
54789 }
54790
54791
54792 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54793 PyObject *resultobj = 0;
54794 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54795 wxSizer *arg2 = (wxSizer *) 0 ;
54796 wxGBSizerItem *result = 0 ;
54797 void *argp1 = 0 ;
54798 int res1 = 0 ;
54799 void *argp2 = 0 ;
54800 int res2 = 0 ;
54801
54802 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54804 if (!SWIG_IsOK(res1)) {
54805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54806 }
54807 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54808 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54809 if (!SWIG_IsOK(res2)) {
54810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54811 }
54812 arg2 = reinterpret_cast< wxSizer * >(argp2);
54813 {
54814 PyThreadState* __tstate = wxPyBeginAllowThreads();
54815 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54816 wxPyEndAllowThreads(__tstate);
54817 if (PyErr_Occurred()) SWIG_fail;
54818 }
54819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54820 return resultobj;
54821 fail:
54822 return NULL;
54823 }
54824
54825
54826 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54827 int argc;
54828 PyObject *argv[3];
54829
54830 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54831 --argc;
54832 if (argc == 2) {
54833 int _v = 0;
54834 {
54835 void *vptr = 0;
54836 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54837 _v = SWIG_CheckState(res);
54838 }
54839 if (!_v) goto check_1;
54840 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54841 }
54842 check_1:
54843
54844 if (argc == 2) {
54845 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54846 }
54847
54848 fail:
54849 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54850 return NULL;
54851 }
54852
54853
54854 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54855 PyObject *resultobj = 0;
54856 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54857 wxGBPosition *arg2 = 0 ;
54858 wxGBSizerItem *result = 0 ;
54859 void *argp1 = 0 ;
54860 int res1 = 0 ;
54861 wxGBPosition temp2 ;
54862 PyObject * obj0 = 0 ;
54863 PyObject * obj1 = 0 ;
54864 char * kwnames[] = {
54865 (char *) "self",(char *) "pos", NULL
54866 };
54867
54868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54870 if (!SWIG_IsOK(res1)) {
54871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54872 }
54873 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54874 {
54875 arg2 = &temp2;
54876 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54877 }
54878 {
54879 PyThreadState* __tstate = wxPyBeginAllowThreads();
54880 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54881 wxPyEndAllowThreads(__tstate);
54882 if (PyErr_Occurred()) SWIG_fail;
54883 }
54884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54885 return resultobj;
54886 fail:
54887 return NULL;
54888 }
54889
54890
54891 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54892 PyObject *resultobj = 0;
54893 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54894 wxPoint *arg2 = 0 ;
54895 wxGBSizerItem *result = 0 ;
54896 void *argp1 = 0 ;
54897 int res1 = 0 ;
54898 wxPoint temp2 ;
54899 PyObject * obj0 = 0 ;
54900 PyObject * obj1 = 0 ;
54901 char * kwnames[] = {
54902 (char *) "self",(char *) "pt", NULL
54903 };
54904
54905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54907 if (!SWIG_IsOK(res1)) {
54908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54909 }
54910 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54911 {
54912 arg2 = &temp2;
54913 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54914 }
54915 {
54916 PyThreadState* __tstate = wxPyBeginAllowThreads();
54917 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54918 wxPyEndAllowThreads(__tstate);
54919 if (PyErr_Occurred()) SWIG_fail;
54920 }
54921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54922 return resultobj;
54923 fail:
54924 return NULL;
54925 }
54926
54927
54928 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54929 PyObject *resultobj = 0;
54930 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54931 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54932 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54933 bool result;
54934 void *argp1 = 0 ;
54935 int res1 = 0 ;
54936 void *argp2 = 0 ;
54937 int res2 = 0 ;
54938 void *argp3 = 0 ;
54939 int res3 = 0 ;
54940 PyObject * obj0 = 0 ;
54941 PyObject * obj1 = 0 ;
54942 PyObject * obj2 = 0 ;
54943 char * kwnames[] = {
54944 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54945 };
54946
54947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54949 if (!SWIG_IsOK(res1)) {
54950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54951 }
54952 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54953 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54954 if (!SWIG_IsOK(res2)) {
54955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54956 }
54957 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54958 if (obj2) {
54959 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54960 if (!SWIG_IsOK(res3)) {
54961 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54962 }
54963 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54964 }
54965 {
54966 PyThreadState* __tstate = wxPyBeginAllowThreads();
54967 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54968 wxPyEndAllowThreads(__tstate);
54969 if (PyErr_Occurred()) SWIG_fail;
54970 }
54971 {
54972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54973 }
54974 return resultobj;
54975 fail:
54976 return NULL;
54977 }
54978
54979
54980 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54981 PyObject *resultobj = 0;
54982 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54983 wxGBPosition *arg2 = 0 ;
54984 wxGBSpan *arg3 = 0 ;
54985 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54986 bool result;
54987 void *argp1 = 0 ;
54988 int res1 = 0 ;
54989 wxGBPosition temp2 ;
54990 wxGBSpan temp3 ;
54991 void *argp4 = 0 ;
54992 int res4 = 0 ;
54993 PyObject * obj0 = 0 ;
54994 PyObject * obj1 = 0 ;
54995 PyObject * obj2 = 0 ;
54996 PyObject * obj3 = 0 ;
54997 char * kwnames[] = {
54998 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54999 };
55000
55001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55003 if (!SWIG_IsOK(res1)) {
55004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55005 }
55006 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55007 {
55008 arg2 = &temp2;
55009 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55010 }
55011 {
55012 arg3 = &temp3;
55013 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55014 }
55015 if (obj3) {
55016 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55017 if (!SWIG_IsOK(res4)) {
55018 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55019 }
55020 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55021 }
55022 {
55023 PyThreadState* __tstate = wxPyBeginAllowThreads();
55024 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55025 wxPyEndAllowThreads(__tstate);
55026 if (PyErr_Occurred()) SWIG_fail;
55027 }
55028 {
55029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55030 }
55031 return resultobj;
55032 fail:
55033 return NULL;
55034 }
55035
55036
55037 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55038 PyObject *obj;
55039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55040 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55041 return SWIG_Py_Void();
55042 }
55043
55044 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55045 return SWIG_Python_InitShadowInstance(args);
55046 }
55047
55048 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55049 PyObject *resultobj = 0;
55050 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55051 wxRelationship arg2 ;
55052 wxWindow *arg3 = (wxWindow *) 0 ;
55053 wxEdge arg4 ;
55054 int arg5 = (int) 0 ;
55055 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55056 void *argp1 = 0 ;
55057 int res1 = 0 ;
55058 int val2 ;
55059 int ecode2 = 0 ;
55060 void *argp3 = 0 ;
55061 int res3 = 0 ;
55062 int val4 ;
55063 int ecode4 = 0 ;
55064 int val5 ;
55065 int ecode5 = 0 ;
55066 int val6 ;
55067 int ecode6 = 0 ;
55068 PyObject * obj0 = 0 ;
55069 PyObject * obj1 = 0 ;
55070 PyObject * obj2 = 0 ;
55071 PyObject * obj3 = 0 ;
55072 PyObject * obj4 = 0 ;
55073 PyObject * obj5 = 0 ;
55074 char * kwnames[] = {
55075 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55076 };
55077
55078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55080 if (!SWIG_IsOK(res1)) {
55081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55082 }
55083 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55084 ecode2 = SWIG_AsVal_int(obj1, &val2);
55085 if (!SWIG_IsOK(ecode2)) {
55086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55087 }
55088 arg2 = static_cast< wxRelationship >(val2);
55089 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55090 if (!SWIG_IsOK(res3)) {
55091 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55092 }
55093 arg3 = reinterpret_cast< wxWindow * >(argp3);
55094 ecode4 = SWIG_AsVal_int(obj3, &val4);
55095 if (!SWIG_IsOK(ecode4)) {
55096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55097 }
55098 arg4 = static_cast< wxEdge >(val4);
55099 if (obj4) {
55100 ecode5 = SWIG_AsVal_int(obj4, &val5);
55101 if (!SWIG_IsOK(ecode5)) {
55102 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55103 }
55104 arg5 = static_cast< int >(val5);
55105 }
55106 if (obj5) {
55107 ecode6 = SWIG_AsVal_int(obj5, &val6);
55108 if (!SWIG_IsOK(ecode6)) {
55109 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55110 }
55111 arg6 = static_cast< int >(val6);
55112 }
55113 {
55114 PyThreadState* __tstate = wxPyBeginAllowThreads();
55115 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55116 wxPyEndAllowThreads(__tstate);
55117 if (PyErr_Occurred()) SWIG_fail;
55118 }
55119 resultobj = SWIG_Py_Void();
55120 return resultobj;
55121 fail:
55122 return NULL;
55123 }
55124
55125
55126 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55127 PyObject *resultobj = 0;
55128 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55129 wxWindow *arg2 = (wxWindow *) 0 ;
55130 int arg3 = (int) 0 ;
55131 void *argp1 = 0 ;
55132 int res1 = 0 ;
55133 void *argp2 = 0 ;
55134 int res2 = 0 ;
55135 int val3 ;
55136 int ecode3 = 0 ;
55137 PyObject * obj0 = 0 ;
55138 PyObject * obj1 = 0 ;
55139 PyObject * obj2 = 0 ;
55140 char * kwnames[] = {
55141 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55142 };
55143
55144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55146 if (!SWIG_IsOK(res1)) {
55147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55148 }
55149 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55150 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55151 if (!SWIG_IsOK(res2)) {
55152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55153 }
55154 arg2 = reinterpret_cast< wxWindow * >(argp2);
55155 if (obj2) {
55156 ecode3 = SWIG_AsVal_int(obj2, &val3);
55157 if (!SWIG_IsOK(ecode3)) {
55158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55159 }
55160 arg3 = static_cast< int >(val3);
55161 }
55162 {
55163 PyThreadState* __tstate = wxPyBeginAllowThreads();
55164 (arg1)->LeftOf(arg2,arg3);
55165 wxPyEndAllowThreads(__tstate);
55166 if (PyErr_Occurred()) SWIG_fail;
55167 }
55168 resultobj = SWIG_Py_Void();
55169 return resultobj;
55170 fail:
55171 return NULL;
55172 }
55173
55174
55175 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55176 PyObject *resultobj = 0;
55177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55178 wxWindow *arg2 = (wxWindow *) 0 ;
55179 int arg3 = (int) 0 ;
55180 void *argp1 = 0 ;
55181 int res1 = 0 ;
55182 void *argp2 = 0 ;
55183 int res2 = 0 ;
55184 int val3 ;
55185 int ecode3 = 0 ;
55186 PyObject * obj0 = 0 ;
55187 PyObject * obj1 = 0 ;
55188 PyObject * obj2 = 0 ;
55189 char * kwnames[] = {
55190 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55191 };
55192
55193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55195 if (!SWIG_IsOK(res1)) {
55196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55197 }
55198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55200 if (!SWIG_IsOK(res2)) {
55201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55202 }
55203 arg2 = reinterpret_cast< wxWindow * >(argp2);
55204 if (obj2) {
55205 ecode3 = SWIG_AsVal_int(obj2, &val3);
55206 if (!SWIG_IsOK(ecode3)) {
55207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55208 }
55209 arg3 = static_cast< int >(val3);
55210 }
55211 {
55212 PyThreadState* __tstate = wxPyBeginAllowThreads();
55213 (arg1)->RightOf(arg2,arg3);
55214 wxPyEndAllowThreads(__tstate);
55215 if (PyErr_Occurred()) SWIG_fail;
55216 }
55217 resultobj = SWIG_Py_Void();
55218 return resultobj;
55219 fail:
55220 return NULL;
55221 }
55222
55223
55224 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55225 PyObject *resultobj = 0;
55226 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55227 wxWindow *arg2 = (wxWindow *) 0 ;
55228 int arg3 = (int) 0 ;
55229 void *argp1 = 0 ;
55230 int res1 = 0 ;
55231 void *argp2 = 0 ;
55232 int res2 = 0 ;
55233 int val3 ;
55234 int ecode3 = 0 ;
55235 PyObject * obj0 = 0 ;
55236 PyObject * obj1 = 0 ;
55237 PyObject * obj2 = 0 ;
55238 char * kwnames[] = {
55239 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55240 };
55241
55242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55244 if (!SWIG_IsOK(res1)) {
55245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55246 }
55247 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55249 if (!SWIG_IsOK(res2)) {
55250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55251 }
55252 arg2 = reinterpret_cast< wxWindow * >(argp2);
55253 if (obj2) {
55254 ecode3 = SWIG_AsVal_int(obj2, &val3);
55255 if (!SWIG_IsOK(ecode3)) {
55256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55257 }
55258 arg3 = static_cast< int >(val3);
55259 }
55260 {
55261 PyThreadState* __tstate = wxPyBeginAllowThreads();
55262 (arg1)->Above(arg2,arg3);
55263 wxPyEndAllowThreads(__tstate);
55264 if (PyErr_Occurred()) SWIG_fail;
55265 }
55266 resultobj = SWIG_Py_Void();
55267 return resultobj;
55268 fail:
55269 return NULL;
55270 }
55271
55272
55273 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55274 PyObject *resultobj = 0;
55275 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55276 wxWindow *arg2 = (wxWindow *) 0 ;
55277 int arg3 = (int) 0 ;
55278 void *argp1 = 0 ;
55279 int res1 = 0 ;
55280 void *argp2 = 0 ;
55281 int res2 = 0 ;
55282 int val3 ;
55283 int ecode3 = 0 ;
55284 PyObject * obj0 = 0 ;
55285 PyObject * obj1 = 0 ;
55286 PyObject * obj2 = 0 ;
55287 char * kwnames[] = {
55288 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55289 };
55290
55291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55293 if (!SWIG_IsOK(res1)) {
55294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55295 }
55296 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55298 if (!SWIG_IsOK(res2)) {
55299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55300 }
55301 arg2 = reinterpret_cast< wxWindow * >(argp2);
55302 if (obj2) {
55303 ecode3 = SWIG_AsVal_int(obj2, &val3);
55304 if (!SWIG_IsOK(ecode3)) {
55305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55306 }
55307 arg3 = static_cast< int >(val3);
55308 }
55309 {
55310 PyThreadState* __tstate = wxPyBeginAllowThreads();
55311 (arg1)->Below(arg2,arg3);
55312 wxPyEndAllowThreads(__tstate);
55313 if (PyErr_Occurred()) SWIG_fail;
55314 }
55315 resultobj = SWIG_Py_Void();
55316 return resultobj;
55317 fail:
55318 return NULL;
55319 }
55320
55321
55322 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55323 PyObject *resultobj = 0;
55324 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55325 wxWindow *arg2 = (wxWindow *) 0 ;
55326 wxEdge arg3 ;
55327 int arg4 = (int) 0 ;
55328 void *argp1 = 0 ;
55329 int res1 = 0 ;
55330 void *argp2 = 0 ;
55331 int res2 = 0 ;
55332 int val3 ;
55333 int ecode3 = 0 ;
55334 int val4 ;
55335 int ecode4 = 0 ;
55336 PyObject * obj0 = 0 ;
55337 PyObject * obj1 = 0 ;
55338 PyObject * obj2 = 0 ;
55339 PyObject * obj3 = 0 ;
55340 char * kwnames[] = {
55341 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55342 };
55343
55344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55346 if (!SWIG_IsOK(res1)) {
55347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55348 }
55349 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55350 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55351 if (!SWIG_IsOK(res2)) {
55352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55353 }
55354 arg2 = reinterpret_cast< wxWindow * >(argp2);
55355 ecode3 = SWIG_AsVal_int(obj2, &val3);
55356 if (!SWIG_IsOK(ecode3)) {
55357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55358 }
55359 arg3 = static_cast< wxEdge >(val3);
55360 if (obj3) {
55361 ecode4 = SWIG_AsVal_int(obj3, &val4);
55362 if (!SWIG_IsOK(ecode4)) {
55363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55364 }
55365 arg4 = static_cast< int >(val4);
55366 }
55367 {
55368 PyThreadState* __tstate = wxPyBeginAllowThreads();
55369 (arg1)->SameAs(arg2,arg3,arg4);
55370 wxPyEndAllowThreads(__tstate);
55371 if (PyErr_Occurred()) SWIG_fail;
55372 }
55373 resultobj = SWIG_Py_Void();
55374 return resultobj;
55375 fail:
55376 return NULL;
55377 }
55378
55379
55380 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55381 PyObject *resultobj = 0;
55382 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55383 wxWindow *arg2 = (wxWindow *) 0 ;
55384 wxEdge arg3 ;
55385 int arg4 ;
55386 void *argp1 = 0 ;
55387 int res1 = 0 ;
55388 void *argp2 = 0 ;
55389 int res2 = 0 ;
55390 int val3 ;
55391 int ecode3 = 0 ;
55392 int val4 ;
55393 int ecode4 = 0 ;
55394 PyObject * obj0 = 0 ;
55395 PyObject * obj1 = 0 ;
55396 PyObject * obj2 = 0 ;
55397 PyObject * obj3 = 0 ;
55398 char * kwnames[] = {
55399 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55400 };
55401
55402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55404 if (!SWIG_IsOK(res1)) {
55405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55406 }
55407 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55409 if (!SWIG_IsOK(res2)) {
55410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55411 }
55412 arg2 = reinterpret_cast< wxWindow * >(argp2);
55413 ecode3 = SWIG_AsVal_int(obj2, &val3);
55414 if (!SWIG_IsOK(ecode3)) {
55415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55416 }
55417 arg3 = static_cast< wxEdge >(val3);
55418 ecode4 = SWIG_AsVal_int(obj3, &val4);
55419 if (!SWIG_IsOK(ecode4)) {
55420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55421 }
55422 arg4 = static_cast< int >(val4);
55423 {
55424 PyThreadState* __tstate = wxPyBeginAllowThreads();
55425 (arg1)->PercentOf(arg2,arg3,arg4);
55426 wxPyEndAllowThreads(__tstate);
55427 if (PyErr_Occurred()) SWIG_fail;
55428 }
55429 resultobj = SWIG_Py_Void();
55430 return resultobj;
55431 fail:
55432 return NULL;
55433 }
55434
55435
55436 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55437 PyObject *resultobj = 0;
55438 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55439 int arg2 ;
55440 void *argp1 = 0 ;
55441 int res1 = 0 ;
55442 int val2 ;
55443 int ecode2 = 0 ;
55444 PyObject * obj0 = 0 ;
55445 PyObject * obj1 = 0 ;
55446 char * kwnames[] = {
55447 (char *) "self",(char *) "val", NULL
55448 };
55449
55450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55452 if (!SWIG_IsOK(res1)) {
55453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55454 }
55455 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55456 ecode2 = SWIG_AsVal_int(obj1, &val2);
55457 if (!SWIG_IsOK(ecode2)) {
55458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55459 }
55460 arg2 = static_cast< int >(val2);
55461 {
55462 PyThreadState* __tstate = wxPyBeginAllowThreads();
55463 (arg1)->Absolute(arg2);
55464 wxPyEndAllowThreads(__tstate);
55465 if (PyErr_Occurred()) SWIG_fail;
55466 }
55467 resultobj = SWIG_Py_Void();
55468 return resultobj;
55469 fail:
55470 return NULL;
55471 }
55472
55473
55474 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55475 PyObject *resultobj = 0;
55476 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55477 void *argp1 = 0 ;
55478 int res1 = 0 ;
55479 PyObject *swig_obj[1] ;
55480
55481 if (!args) SWIG_fail;
55482 swig_obj[0] = args;
55483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55484 if (!SWIG_IsOK(res1)) {
55485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55486 }
55487 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55488 {
55489 PyThreadState* __tstate = wxPyBeginAllowThreads();
55490 (arg1)->Unconstrained();
55491 wxPyEndAllowThreads(__tstate);
55492 if (PyErr_Occurred()) SWIG_fail;
55493 }
55494 resultobj = SWIG_Py_Void();
55495 return resultobj;
55496 fail:
55497 return NULL;
55498 }
55499
55500
55501 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55502 PyObject *resultobj = 0;
55503 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55504 void *argp1 = 0 ;
55505 int res1 = 0 ;
55506 PyObject *swig_obj[1] ;
55507
55508 if (!args) SWIG_fail;
55509 swig_obj[0] = args;
55510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55511 if (!SWIG_IsOK(res1)) {
55512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55513 }
55514 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55515 {
55516 PyThreadState* __tstate = wxPyBeginAllowThreads();
55517 (arg1)->AsIs();
55518 wxPyEndAllowThreads(__tstate);
55519 if (PyErr_Occurred()) SWIG_fail;
55520 }
55521 resultobj = SWIG_Py_Void();
55522 return resultobj;
55523 fail:
55524 return NULL;
55525 }
55526
55527
55528 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55529 PyObject *resultobj = 0;
55530 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55531 wxWindow *result = 0 ;
55532 void *argp1 = 0 ;
55533 int res1 = 0 ;
55534 PyObject *swig_obj[1] ;
55535
55536 if (!args) SWIG_fail;
55537 swig_obj[0] = args;
55538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55539 if (!SWIG_IsOK(res1)) {
55540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55541 }
55542 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55543 {
55544 PyThreadState* __tstate = wxPyBeginAllowThreads();
55545 result = (wxWindow *)(arg1)->GetOtherWindow();
55546 wxPyEndAllowThreads(__tstate);
55547 if (PyErr_Occurred()) SWIG_fail;
55548 }
55549 {
55550 resultobj = wxPyMake_wxObject(result, 0);
55551 }
55552 return resultobj;
55553 fail:
55554 return NULL;
55555 }
55556
55557
55558 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55559 PyObject *resultobj = 0;
55560 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55561 wxEdge result;
55562 void *argp1 = 0 ;
55563 int res1 = 0 ;
55564 PyObject *swig_obj[1] ;
55565
55566 if (!args) SWIG_fail;
55567 swig_obj[0] = args;
55568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55569 if (!SWIG_IsOK(res1)) {
55570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55571 }
55572 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55573 {
55574 PyThreadState* __tstate = wxPyBeginAllowThreads();
55575 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55576 wxPyEndAllowThreads(__tstate);
55577 if (PyErr_Occurred()) SWIG_fail;
55578 }
55579 resultobj = SWIG_From_int(static_cast< int >(result));
55580 return resultobj;
55581 fail:
55582 return NULL;
55583 }
55584
55585
55586 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55587 PyObject *resultobj = 0;
55588 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55589 wxEdge arg2 ;
55590 void *argp1 = 0 ;
55591 int res1 = 0 ;
55592 int val2 ;
55593 int ecode2 = 0 ;
55594 PyObject * obj0 = 0 ;
55595 PyObject * obj1 = 0 ;
55596 char * kwnames[] = {
55597 (char *) "self",(char *) "which", NULL
55598 };
55599
55600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55602 if (!SWIG_IsOK(res1)) {
55603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55604 }
55605 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55606 ecode2 = SWIG_AsVal_int(obj1, &val2);
55607 if (!SWIG_IsOK(ecode2)) {
55608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55609 }
55610 arg2 = static_cast< wxEdge >(val2);
55611 {
55612 PyThreadState* __tstate = wxPyBeginAllowThreads();
55613 (arg1)->SetEdge(arg2);
55614 wxPyEndAllowThreads(__tstate);
55615 if (PyErr_Occurred()) SWIG_fail;
55616 }
55617 resultobj = SWIG_Py_Void();
55618 return resultobj;
55619 fail:
55620 return NULL;
55621 }
55622
55623
55624 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55625 PyObject *resultobj = 0;
55626 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55627 int arg2 ;
55628 void *argp1 = 0 ;
55629 int res1 = 0 ;
55630 int val2 ;
55631 int ecode2 = 0 ;
55632 PyObject * obj0 = 0 ;
55633 PyObject * obj1 = 0 ;
55634 char * kwnames[] = {
55635 (char *) "self",(char *) "v", NULL
55636 };
55637
55638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55640 if (!SWIG_IsOK(res1)) {
55641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55642 }
55643 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55644 ecode2 = SWIG_AsVal_int(obj1, &val2);
55645 if (!SWIG_IsOK(ecode2)) {
55646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55647 }
55648 arg2 = static_cast< int >(val2);
55649 {
55650 PyThreadState* __tstate = wxPyBeginAllowThreads();
55651 (arg1)->SetValue(arg2);
55652 wxPyEndAllowThreads(__tstate);
55653 if (PyErr_Occurred()) SWIG_fail;
55654 }
55655 resultobj = SWIG_Py_Void();
55656 return resultobj;
55657 fail:
55658 return NULL;
55659 }
55660
55661
55662 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55663 PyObject *resultobj = 0;
55664 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55665 int result;
55666 void *argp1 = 0 ;
55667 int res1 = 0 ;
55668 PyObject *swig_obj[1] ;
55669
55670 if (!args) SWIG_fail;
55671 swig_obj[0] = args;
55672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55673 if (!SWIG_IsOK(res1)) {
55674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55675 }
55676 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55677 {
55678 PyThreadState* __tstate = wxPyBeginAllowThreads();
55679 result = (int)(arg1)->GetMargin();
55680 wxPyEndAllowThreads(__tstate);
55681 if (PyErr_Occurred()) SWIG_fail;
55682 }
55683 resultobj = SWIG_From_int(static_cast< int >(result));
55684 return resultobj;
55685 fail:
55686 return NULL;
55687 }
55688
55689
55690 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55691 PyObject *resultobj = 0;
55692 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55693 int arg2 ;
55694 void *argp1 = 0 ;
55695 int res1 = 0 ;
55696 int val2 ;
55697 int ecode2 = 0 ;
55698 PyObject * obj0 = 0 ;
55699 PyObject * obj1 = 0 ;
55700 char * kwnames[] = {
55701 (char *) "self",(char *) "m", NULL
55702 };
55703
55704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55706 if (!SWIG_IsOK(res1)) {
55707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55708 }
55709 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55710 ecode2 = SWIG_AsVal_int(obj1, &val2);
55711 if (!SWIG_IsOK(ecode2)) {
55712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55713 }
55714 arg2 = static_cast< int >(val2);
55715 {
55716 PyThreadState* __tstate = wxPyBeginAllowThreads();
55717 (arg1)->SetMargin(arg2);
55718 wxPyEndAllowThreads(__tstate);
55719 if (PyErr_Occurred()) SWIG_fail;
55720 }
55721 resultobj = SWIG_Py_Void();
55722 return resultobj;
55723 fail:
55724 return NULL;
55725 }
55726
55727
55728 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55729 PyObject *resultobj = 0;
55730 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55731 int result;
55732 void *argp1 = 0 ;
55733 int res1 = 0 ;
55734 PyObject *swig_obj[1] ;
55735
55736 if (!args) SWIG_fail;
55737 swig_obj[0] = args;
55738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55739 if (!SWIG_IsOK(res1)) {
55740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55741 }
55742 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55743 {
55744 PyThreadState* __tstate = wxPyBeginAllowThreads();
55745 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55746 wxPyEndAllowThreads(__tstate);
55747 if (PyErr_Occurred()) SWIG_fail;
55748 }
55749 resultobj = SWIG_From_int(static_cast< int >(result));
55750 return resultobj;
55751 fail:
55752 return NULL;
55753 }
55754
55755
55756 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55757 PyObject *resultobj = 0;
55758 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55759 int result;
55760 void *argp1 = 0 ;
55761 int res1 = 0 ;
55762 PyObject *swig_obj[1] ;
55763
55764 if (!args) SWIG_fail;
55765 swig_obj[0] = args;
55766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55767 if (!SWIG_IsOK(res1)) {
55768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55769 }
55770 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55771 {
55772 PyThreadState* __tstate = wxPyBeginAllowThreads();
55773 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55774 wxPyEndAllowThreads(__tstate);
55775 if (PyErr_Occurred()) SWIG_fail;
55776 }
55777 resultobj = SWIG_From_int(static_cast< int >(result));
55778 return resultobj;
55779 fail:
55780 return NULL;
55781 }
55782
55783
55784 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55785 PyObject *resultobj = 0;
55786 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55787 int result;
55788 void *argp1 = 0 ;
55789 int res1 = 0 ;
55790 PyObject *swig_obj[1] ;
55791
55792 if (!args) SWIG_fail;
55793 swig_obj[0] = args;
55794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55795 if (!SWIG_IsOK(res1)) {
55796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55797 }
55798 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55799 {
55800 PyThreadState* __tstate = wxPyBeginAllowThreads();
55801 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55802 wxPyEndAllowThreads(__tstate);
55803 if (PyErr_Occurred()) SWIG_fail;
55804 }
55805 resultobj = SWIG_From_int(static_cast< int >(result));
55806 return resultobj;
55807 fail:
55808 return NULL;
55809 }
55810
55811
55812 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55813 PyObject *resultobj = 0;
55814 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55815 bool result;
55816 void *argp1 = 0 ;
55817 int res1 = 0 ;
55818 PyObject *swig_obj[1] ;
55819
55820 if (!args) SWIG_fail;
55821 swig_obj[0] = args;
55822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55823 if (!SWIG_IsOK(res1)) {
55824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55825 }
55826 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55827 {
55828 PyThreadState* __tstate = wxPyBeginAllowThreads();
55829 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55830 wxPyEndAllowThreads(__tstate);
55831 if (PyErr_Occurred()) SWIG_fail;
55832 }
55833 {
55834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55835 }
55836 return resultobj;
55837 fail:
55838 return NULL;
55839 }
55840
55841
55842 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55843 PyObject *resultobj = 0;
55844 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55845 bool arg2 ;
55846 void *argp1 = 0 ;
55847 int res1 = 0 ;
55848 bool val2 ;
55849 int ecode2 = 0 ;
55850 PyObject * obj0 = 0 ;
55851 PyObject * obj1 = 0 ;
55852 char * kwnames[] = {
55853 (char *) "self",(char *) "d", NULL
55854 };
55855
55856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55858 if (!SWIG_IsOK(res1)) {
55859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55860 }
55861 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55862 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55863 if (!SWIG_IsOK(ecode2)) {
55864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55865 }
55866 arg2 = static_cast< bool >(val2);
55867 {
55868 PyThreadState* __tstate = wxPyBeginAllowThreads();
55869 (arg1)->SetDone(arg2);
55870 wxPyEndAllowThreads(__tstate);
55871 if (PyErr_Occurred()) SWIG_fail;
55872 }
55873 resultobj = SWIG_Py_Void();
55874 return resultobj;
55875 fail:
55876 return NULL;
55877 }
55878
55879
55880 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55881 PyObject *resultobj = 0;
55882 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55883 wxRelationship result;
55884 void *argp1 = 0 ;
55885 int res1 = 0 ;
55886 PyObject *swig_obj[1] ;
55887
55888 if (!args) SWIG_fail;
55889 swig_obj[0] = args;
55890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55891 if (!SWIG_IsOK(res1)) {
55892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55893 }
55894 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55895 {
55896 PyThreadState* __tstate = wxPyBeginAllowThreads();
55897 result = (wxRelationship)(arg1)->GetRelationship();
55898 wxPyEndAllowThreads(__tstate);
55899 if (PyErr_Occurred()) SWIG_fail;
55900 }
55901 resultobj = SWIG_From_int(static_cast< int >(result));
55902 return resultobj;
55903 fail:
55904 return NULL;
55905 }
55906
55907
55908 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55909 PyObject *resultobj = 0;
55910 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55911 wxRelationship arg2 ;
55912 void *argp1 = 0 ;
55913 int res1 = 0 ;
55914 int val2 ;
55915 int ecode2 = 0 ;
55916 PyObject * obj0 = 0 ;
55917 PyObject * obj1 = 0 ;
55918 char * kwnames[] = {
55919 (char *) "self",(char *) "r", NULL
55920 };
55921
55922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55924 if (!SWIG_IsOK(res1)) {
55925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55926 }
55927 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55928 ecode2 = SWIG_AsVal_int(obj1, &val2);
55929 if (!SWIG_IsOK(ecode2)) {
55930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55931 }
55932 arg2 = static_cast< wxRelationship >(val2);
55933 {
55934 PyThreadState* __tstate = wxPyBeginAllowThreads();
55935 (arg1)->SetRelationship(arg2);
55936 wxPyEndAllowThreads(__tstate);
55937 if (PyErr_Occurred()) SWIG_fail;
55938 }
55939 resultobj = SWIG_Py_Void();
55940 return resultobj;
55941 fail:
55942 return NULL;
55943 }
55944
55945
55946 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55947 PyObject *resultobj = 0;
55948 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55949 wxWindow *arg2 = (wxWindow *) 0 ;
55950 bool result;
55951 void *argp1 = 0 ;
55952 int res1 = 0 ;
55953 void *argp2 = 0 ;
55954 int res2 = 0 ;
55955 PyObject * obj0 = 0 ;
55956 PyObject * obj1 = 0 ;
55957 char * kwnames[] = {
55958 (char *) "self",(char *) "otherW", NULL
55959 };
55960
55961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55963 if (!SWIG_IsOK(res1)) {
55964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55965 }
55966 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55968 if (!SWIG_IsOK(res2)) {
55969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55970 }
55971 arg2 = reinterpret_cast< wxWindow * >(argp2);
55972 {
55973 PyThreadState* __tstate = wxPyBeginAllowThreads();
55974 result = (bool)(arg1)->ResetIfWin(arg2);
55975 wxPyEndAllowThreads(__tstate);
55976 if (PyErr_Occurred()) SWIG_fail;
55977 }
55978 {
55979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55980 }
55981 return resultobj;
55982 fail:
55983 return NULL;
55984 }
55985
55986
55987 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55988 PyObject *resultobj = 0;
55989 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55990 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55991 wxWindow *arg3 = (wxWindow *) 0 ;
55992 bool result;
55993 void *argp1 = 0 ;
55994 int res1 = 0 ;
55995 void *argp2 = 0 ;
55996 int res2 = 0 ;
55997 void *argp3 = 0 ;
55998 int res3 = 0 ;
55999 PyObject * obj0 = 0 ;
56000 PyObject * obj1 = 0 ;
56001 PyObject * obj2 = 0 ;
56002 char * kwnames[] = {
56003 (char *) "self",(char *) "constraints",(char *) "win", NULL
56004 };
56005
56006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56008 if (!SWIG_IsOK(res1)) {
56009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56010 }
56011 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56012 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56013 if (!SWIG_IsOK(res2)) {
56014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56015 }
56016 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56017 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56018 if (!SWIG_IsOK(res3)) {
56019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56020 }
56021 arg3 = reinterpret_cast< wxWindow * >(argp3);
56022 {
56023 PyThreadState* __tstate = wxPyBeginAllowThreads();
56024 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56025 wxPyEndAllowThreads(__tstate);
56026 if (PyErr_Occurred()) SWIG_fail;
56027 }
56028 {
56029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56030 }
56031 return resultobj;
56032 fail:
56033 return NULL;
56034 }
56035
56036
56037 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56038 PyObject *resultobj = 0;
56039 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56040 wxEdge arg2 ;
56041 wxWindow *arg3 = (wxWindow *) 0 ;
56042 wxWindow *arg4 = (wxWindow *) 0 ;
56043 int result;
56044 void *argp1 = 0 ;
56045 int res1 = 0 ;
56046 int val2 ;
56047 int ecode2 = 0 ;
56048 void *argp3 = 0 ;
56049 int res3 = 0 ;
56050 void *argp4 = 0 ;
56051 int res4 = 0 ;
56052 PyObject * obj0 = 0 ;
56053 PyObject * obj1 = 0 ;
56054 PyObject * obj2 = 0 ;
56055 PyObject * obj3 = 0 ;
56056 char * kwnames[] = {
56057 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56058 };
56059
56060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56062 if (!SWIG_IsOK(res1)) {
56063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56064 }
56065 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56066 ecode2 = SWIG_AsVal_int(obj1, &val2);
56067 if (!SWIG_IsOK(ecode2)) {
56068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56069 }
56070 arg2 = static_cast< wxEdge >(val2);
56071 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56072 if (!SWIG_IsOK(res3)) {
56073 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56074 }
56075 arg3 = reinterpret_cast< wxWindow * >(argp3);
56076 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56077 if (!SWIG_IsOK(res4)) {
56078 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56079 }
56080 arg4 = reinterpret_cast< wxWindow * >(argp4);
56081 {
56082 PyThreadState* __tstate = wxPyBeginAllowThreads();
56083 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56084 wxPyEndAllowThreads(__tstate);
56085 if (PyErr_Occurred()) SWIG_fail;
56086 }
56087 resultobj = SWIG_From_int(static_cast< int >(result));
56088 return resultobj;
56089 fail:
56090 return NULL;
56091 }
56092
56093
56094 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56095 PyObject *obj;
56096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56097 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56098 return SWIG_Py_Void();
56099 }
56100
56101 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56102 PyObject *resultobj = 0;
56103 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56104 wxIndividualLayoutConstraint *result = 0 ;
56105 void *argp1 = 0 ;
56106 int res1 = 0 ;
56107 PyObject *swig_obj[1] ;
56108
56109 if (!args) SWIG_fail;
56110 swig_obj[0] = args;
56111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56112 if (!SWIG_IsOK(res1)) {
56113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56114 }
56115 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56116 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56118 return resultobj;
56119 fail:
56120 return NULL;
56121 }
56122
56123
56124 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56125 PyObject *resultobj = 0;
56126 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56127 wxIndividualLayoutConstraint *result = 0 ;
56128 void *argp1 = 0 ;
56129 int res1 = 0 ;
56130 PyObject *swig_obj[1] ;
56131
56132 if (!args) SWIG_fail;
56133 swig_obj[0] = args;
56134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56135 if (!SWIG_IsOK(res1)) {
56136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56137 }
56138 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56139 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56141 return resultobj;
56142 fail:
56143 return NULL;
56144 }
56145
56146
56147 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56148 PyObject *resultobj = 0;
56149 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56150 wxIndividualLayoutConstraint *result = 0 ;
56151 void *argp1 = 0 ;
56152 int res1 = 0 ;
56153 PyObject *swig_obj[1] ;
56154
56155 if (!args) SWIG_fail;
56156 swig_obj[0] = args;
56157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56158 if (!SWIG_IsOK(res1)) {
56159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56160 }
56161 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56162 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56164 return resultobj;
56165 fail:
56166 return NULL;
56167 }
56168
56169
56170 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56171 PyObject *resultobj = 0;
56172 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56173 wxIndividualLayoutConstraint *result = 0 ;
56174 void *argp1 = 0 ;
56175 int res1 = 0 ;
56176 PyObject *swig_obj[1] ;
56177
56178 if (!args) SWIG_fail;
56179 swig_obj[0] = args;
56180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56181 if (!SWIG_IsOK(res1)) {
56182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56183 }
56184 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56185 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56187 return resultobj;
56188 fail:
56189 return NULL;
56190 }
56191
56192
56193 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56194 PyObject *resultobj = 0;
56195 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56196 wxIndividualLayoutConstraint *result = 0 ;
56197 void *argp1 = 0 ;
56198 int res1 = 0 ;
56199 PyObject *swig_obj[1] ;
56200
56201 if (!args) SWIG_fail;
56202 swig_obj[0] = args;
56203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56204 if (!SWIG_IsOK(res1)) {
56205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56206 }
56207 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56208 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56210 return resultobj;
56211 fail:
56212 return NULL;
56213 }
56214
56215
56216 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56217 PyObject *resultobj = 0;
56218 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56219 wxIndividualLayoutConstraint *result = 0 ;
56220 void *argp1 = 0 ;
56221 int res1 = 0 ;
56222 PyObject *swig_obj[1] ;
56223
56224 if (!args) SWIG_fail;
56225 swig_obj[0] = args;
56226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56227 if (!SWIG_IsOK(res1)) {
56228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56229 }
56230 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56231 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56233 return resultobj;
56234 fail:
56235 return NULL;
56236 }
56237
56238
56239 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56240 PyObject *resultobj = 0;
56241 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56242 wxIndividualLayoutConstraint *result = 0 ;
56243 void *argp1 = 0 ;
56244 int res1 = 0 ;
56245 PyObject *swig_obj[1] ;
56246
56247 if (!args) SWIG_fail;
56248 swig_obj[0] = args;
56249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56250 if (!SWIG_IsOK(res1)) {
56251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56252 }
56253 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56254 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56256 return resultobj;
56257 fail:
56258 return NULL;
56259 }
56260
56261
56262 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56263 PyObject *resultobj = 0;
56264 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56265 wxIndividualLayoutConstraint *result = 0 ;
56266 void *argp1 = 0 ;
56267 int res1 = 0 ;
56268 PyObject *swig_obj[1] ;
56269
56270 if (!args) SWIG_fail;
56271 swig_obj[0] = args;
56272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56273 if (!SWIG_IsOK(res1)) {
56274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56275 }
56276 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56277 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56279 return resultobj;
56280 fail:
56281 return NULL;
56282 }
56283
56284
56285 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56286 PyObject *resultobj = 0;
56287 wxLayoutConstraints *result = 0 ;
56288
56289 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56290 {
56291 PyThreadState* __tstate = wxPyBeginAllowThreads();
56292 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56293 wxPyEndAllowThreads(__tstate);
56294 if (PyErr_Occurred()) SWIG_fail;
56295 }
56296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56297 return resultobj;
56298 fail:
56299 return NULL;
56300 }
56301
56302
56303 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56304 PyObject *resultobj = 0;
56305 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56306 void *argp1 = 0 ;
56307 int res1 = 0 ;
56308 PyObject *swig_obj[1] ;
56309
56310 if (!args) SWIG_fail;
56311 swig_obj[0] = args;
56312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56313 if (!SWIG_IsOK(res1)) {
56314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56315 }
56316 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56317 {
56318 PyThreadState* __tstate = wxPyBeginAllowThreads();
56319 delete arg1;
56320
56321 wxPyEndAllowThreads(__tstate);
56322 if (PyErr_Occurred()) SWIG_fail;
56323 }
56324 resultobj = SWIG_Py_Void();
56325 return resultobj;
56326 fail:
56327 return NULL;
56328 }
56329
56330
56331 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56332 PyObject *resultobj = 0;
56333 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56334 wxWindow *arg2 = (wxWindow *) 0 ;
56335 int *arg3 = (int *) 0 ;
56336 bool result;
56337 void *argp1 = 0 ;
56338 int res1 = 0 ;
56339 void *argp2 = 0 ;
56340 int res2 = 0 ;
56341 int temp3 ;
56342 int res3 = SWIG_TMPOBJ ;
56343 PyObject * obj0 = 0 ;
56344 PyObject * obj1 = 0 ;
56345 char * kwnames[] = {
56346 (char *) "self",(char *) "win", NULL
56347 };
56348
56349 arg3 = &temp3;
56350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56352 if (!SWIG_IsOK(res1)) {
56353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56354 }
56355 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56357 if (!SWIG_IsOK(res2)) {
56358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56359 }
56360 arg2 = reinterpret_cast< wxWindow * >(argp2);
56361 {
56362 PyThreadState* __tstate = wxPyBeginAllowThreads();
56363 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56364 wxPyEndAllowThreads(__tstate);
56365 if (PyErr_Occurred()) SWIG_fail;
56366 }
56367 {
56368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56369 }
56370 if (SWIG_IsTmpObj(res3)) {
56371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56372 } else {
56373 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56375 }
56376 return resultobj;
56377 fail:
56378 return NULL;
56379 }
56380
56381
56382 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56383 PyObject *resultobj = 0;
56384 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56385 bool result;
56386 void *argp1 = 0 ;
56387 int res1 = 0 ;
56388 PyObject *swig_obj[1] ;
56389
56390 if (!args) SWIG_fail;
56391 swig_obj[0] = args;
56392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56393 if (!SWIG_IsOK(res1)) {
56394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56395 }
56396 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56397 {
56398 PyThreadState* __tstate = wxPyBeginAllowThreads();
56399 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56400 wxPyEndAllowThreads(__tstate);
56401 if (PyErr_Occurred()) SWIG_fail;
56402 }
56403 {
56404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56405 }
56406 return resultobj;
56407 fail:
56408 return NULL;
56409 }
56410
56411
56412 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56413 PyObject *obj;
56414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56415 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56416 return SWIG_Py_Void();
56417 }
56418
56419 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56420 return SWIG_Python_InitShadowInstance(args);
56421 }
56422
56423 static PyMethodDef SwigMethods[] = {
56424 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56425 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56426 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56427 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56428 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56429 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56430 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56431 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56432 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56433 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56434 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56435 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56437 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56439 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56441 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56442 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56443 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56445 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56448 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56449 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56450 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56452 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56453 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56454 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56455 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56456 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56457 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56458 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56460 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56466 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56467 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56468 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56469 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56470 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56471 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56472 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56474 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56482 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56483 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56484 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56489 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56490 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56492 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56494 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56496 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56498 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56500 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56502 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56503 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56505 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56507 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56509 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56511 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56512 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56513 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56514 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56534 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56535 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56536 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56537 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56538 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56539 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56540 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56541 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56543 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56544 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56545 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56550 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56551 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56552 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56553 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56554 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56555 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56561 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56568 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56569 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56570 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56571 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56573 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56574 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56575 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56577 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56578 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56579 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56580 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56583 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56586 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56589 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56592 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56594 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56595 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56598 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56601 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56604 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56610 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56612 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56614 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56621 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56624 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56625 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56626 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56627 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56628 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56629 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56630 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56631 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56633 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56634 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56635 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56637 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56638 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56639 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56640 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56645 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56646 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56647 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56648 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56649 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56650 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56652 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56653 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56654 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56655 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56657 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56658 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56660 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56661 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56662 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56663 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56664 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56665 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56666 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56667 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56668 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56669 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56670 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56671 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56675 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56676 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56680 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56681 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56682 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56683 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56684 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56685 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56687 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56690 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56693 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56696 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56697 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56698 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56701 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56702 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56703 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56707 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56708 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56709 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56713 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56718 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56719 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56720 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56721 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56722 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56723 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56724 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56731 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56732 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56734 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56735 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56736 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56742 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56743 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56745 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56746 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56747 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56748 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56749 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56750 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56751 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56752 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56754 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56755 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56756 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56757 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56758 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56759 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56760 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56761 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56763 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56772 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56774 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56789 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56790 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56805 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56806 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56807 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56808 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56811 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56813 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56815 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56817 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56819 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56822 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56823 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56824 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56825 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56827 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56837 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56844 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56845 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56851 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56852 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56854 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56855 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56856 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56857 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56858 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56859 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56860 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56861 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56862 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56863 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56864 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56865 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56866 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56867 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56868 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56869 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56870 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56871 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56872 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56873 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56874 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56875 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56876 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56877 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56878 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56879 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56880 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56881 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56882 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56883 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56884 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56885 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56886 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56887 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56888 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56889 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56890 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56891 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56892 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56893 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56894 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56895 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56896 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56897 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56898 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56899 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56900 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56901 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56904 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56905 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56906 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56907 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56908 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56910 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56911 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56912 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56913 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56915 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56917 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56918 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56919 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56920 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56921 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56923 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56924 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56926 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56927 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56928 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56930 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56931 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56932 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56933 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56934 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56935 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56936 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56937 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56938 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56940 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56942 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56943 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56944 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56945 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56946 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56947 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56948 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56949 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56950 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56951 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56952 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56953 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56955 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56956 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56959 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56960 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56961 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56962 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56963 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56966 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56967 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56968 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56969 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56970 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56971 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56972 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56973 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56974 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56975 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56976 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56977 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56978 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56979 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56980 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56981 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56982 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56983 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56984 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56985 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56986 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56987 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56988 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56989 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56990 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56991 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56992 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56993 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56994 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56995 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56996 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56997 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56998 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56999 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57000 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57001 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57002 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57003 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57004 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57005 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57006 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57007 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57008 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57009 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57010 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57011 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57012 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57013 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57014 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57015 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57016 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57017 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57018 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57019 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57020 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57021 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57022 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57023 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57024 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57025 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57026 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57027 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57028 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57029 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57030 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57031 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57032 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57033 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57034 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57035 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57036 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57037 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57038 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57039 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57040 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57041 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57042 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57043 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57044 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57045 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57046 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57047 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57048 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57049 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57050 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57051 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57052 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57053 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57054 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57055 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57056 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57057 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57058 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57059 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57060 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57061 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57062 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57063 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57064 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57065 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57066 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57067 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57068 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57069 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57070 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57071 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57072 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57073 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57074 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57075 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57076 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57077 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57078 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57079 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57080 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57081 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57082 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57083 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57084 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57085 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57086 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57087 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57088 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57089 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57090 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57091 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57092 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57093 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57094 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57095 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57096 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57097 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57098 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57099 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57101 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57102 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57103 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57104 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57105 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57106 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57107 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57108 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57110 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57111 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57112 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57113 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57114 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57115 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57116 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57117 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57118 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57119 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57120 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57121 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57122 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57124 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57125 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57126 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57127 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57128 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57129 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57130 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57131 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57133 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57134 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57135 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57136 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57137 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57139 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57140 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57141 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57142 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57143 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57144 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57145 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57146 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57147 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57148 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57149 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57150 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57151 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57152 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57153 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57154 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57155 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57156 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57157 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57158 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57159 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57160 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57161 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57162 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57165 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57166 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57167 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57168 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57169 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57170 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57171 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57172 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57173 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57174 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57175 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57176 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57177 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57178 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57179 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57180 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57181 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57182 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57183 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57184 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57185 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57186 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57187 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57190 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57191 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57192 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57194 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57195 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57196 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57197 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57198 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57199 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57200 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57201 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57203 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57205 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57206 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57207 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57208 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57209 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57211 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57212 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57213 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57214 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57215 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57216 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57217 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57218 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57219 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57221 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57222 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57223 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57225 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57226 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57227 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57228 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57229 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57230 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57231 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57232 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57233 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57235 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57236 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57237 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57238 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57239 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57241 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57242 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57243 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57244 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57245 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57247 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57248 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57249 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57250 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57251 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57252 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57253 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57254 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57255 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57256 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57258 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57259 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57260 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57261 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57262 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57263 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57264 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57265 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57266 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57267 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57268 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57269 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57270 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57271 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57273 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57275 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57276 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57277 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57279 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57281 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57283 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57284 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57285 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57286 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57287 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57288 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57289 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57290 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57293 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57294 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57295 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57296 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57297 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57298 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57299 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57300 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57301 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57303 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57305 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57306 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57307 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57308 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57309 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57310 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57311 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57313 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57314 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57315 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57316 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57318 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57319 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57321 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57322 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57323 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57324 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57325 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57328 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57329 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57330 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57331 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57332 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57334 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57335 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57337 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57338 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57339 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57340 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57341 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57342 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57343 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57344 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57345 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57346 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57347 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57348 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57349 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57350 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57351 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57353 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57355 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57356 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57357 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57358 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57359 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57360 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57362 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57364 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57365 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57366 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57367 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57369 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57370 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57374 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57380 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57381 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57383 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57384 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57385 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57386 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57387 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57388 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57389 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57390 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57391 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57392 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57393 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57394 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57395 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57396 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57397 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57398 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57399 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57401 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57404 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57405 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57409 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57410 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57411 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57412 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57414 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57415 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57416 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57417 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57420 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57421 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
57422 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57423 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57425 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57427 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57428 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57429 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57430 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57432 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57434 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57436 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57437 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57440 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57441 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57442 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57443 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57444 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57445 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57448 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57449 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57450 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57451 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57452 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57459 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57465 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57466 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57467 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57468 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57469 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57471 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57481 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57482 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57483 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57484 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57487 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57488 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57489 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57490 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57491 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57493 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57494 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57495 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57499 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57505 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57506 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57507 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57508 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57510 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57511 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57513 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57516 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57518 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57519 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57520 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57529 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57533 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57534 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57536 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57546 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57547 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57548 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57549 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57553 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57556 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57558 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57561 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57563 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57564 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57567 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57569 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57570 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57571 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57572 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57574 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57575 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57580 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57581 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57582 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57584 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57585 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57586 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57588 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57590 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57591 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57592 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57594 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57595 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57598 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57606 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57613 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57621 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57624 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57625 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57638 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57640 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57642 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57643 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57645 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57647 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57648 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57650 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57651 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57652 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57656 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57675 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57676 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57678 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57679 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57681 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57682 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57683 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57685 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57686 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57689 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57690 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57692 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57693 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57695 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57698 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57699 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57701 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57703 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57705 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57706 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57708 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57709 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57712 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57714 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57716 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57718 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57721 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57723 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57724 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57725 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57727 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57728 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57729 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57731 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57733 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57734 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57737 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57738 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57742 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57746 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57747 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57749 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57753 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57755 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57757 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57758 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57759 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57760 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57764 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57765 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57766 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57767 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57769 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57770 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57775 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57776 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57777 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57778 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57779 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57781 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57783 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57785 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57786 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57788 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57790 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57793 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57794 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57795 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57797 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57798 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57799 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57802 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57812 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57818 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57819 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57820 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57821 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57822 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57823 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57829 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57830 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57834 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57835 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57837 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57838 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57839 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57840 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57842 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57843 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57845 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57846 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57847 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57853 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57854 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57855 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57856 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57857 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57858 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57865 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57867 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57868 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57869 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57870 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57871 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57872 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57874 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57878 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57879 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57880 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57881 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57882 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57883 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57884 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57886 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57887 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57888 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57894 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57895 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57896 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57898 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57899 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57900 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57906 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57907 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57908 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57909 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57910 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57914 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57915 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57920 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57921 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57923 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57924 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57926 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57929 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57931 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57932 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57933 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57934 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57935 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57940 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57941 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57950 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57951 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57952 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57953 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57956 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57958 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57959 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57960 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57961 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57963 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57968 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57969 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57970 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57971 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57972 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57973 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57974 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57975 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57976 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57977 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57978 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57979 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57980 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57981 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57982 { NULL, NULL, 0, NULL }
57983 };
57984
57985
57986 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57987
57988 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57989 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57990 }
57991 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57992 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57993 }
57994 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57995 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57996 }
57997 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57998 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57999 }
58000 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58001 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58002 }
58003 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58004 return (void *)((wxSizer *) ((wxGridSizer *) x));
58005 }
58006 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58007 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58008 }
58009 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58010 return (void *)((wxSizer *) ((wxPySizer *) x));
58011 }
58012 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58013 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58014 }
58015 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58016 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58017 }
58018 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58019 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58020 }
58021 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58022 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58023 }
58024 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58025 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58026 }
58027 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58028 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58029 }
58030 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58031 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58032 }
58033 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58034 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58035 }
58036 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58037 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58038 }
58039 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58040 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58041 }
58042 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58043 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58044 }
58045 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58047 }
58048 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58049 return (void *)((wxEvent *) ((wxPyEvent *) x));
58050 }
58051 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58052 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58053 }
58054 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58055 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58056 }
58057 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58058 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58059 }
58060 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58061 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58062 }
58063 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58064 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58065 }
58066 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58067 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58068 }
58069 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58070 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58071 }
58072 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58073 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58074 }
58075 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58076 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58077 }
58078 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58079 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58080 }
58081 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58082 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58083 }
58084 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58085 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58086 }
58087 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58088 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58089 }
58090 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58091 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58092 }
58093 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58094 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58095 }
58096 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58097 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58098 }
58099 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58100 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58101 }
58102 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58103 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58104 }
58105 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58106 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58107 }
58108 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58109 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58110 }
58111 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58112 return (void *)((wxEvent *) ((wxShowEvent *) x));
58113 }
58114 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58115 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58116 }
58117 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58118 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58119 }
58120 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58121 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58122 }
58123 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58124 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58125 }
58126 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58127 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58128 }
58129 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58130 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58131 }
58132 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58133 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58134 }
58135 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58136 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58137 }
58138 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58139 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58140 }
58141 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58142 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58143 }
58144 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58145 return (void *)((wxControl *) ((wxControlWithItems *) x));
58146 }
58147 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58148 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58149 }
58150 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58151 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58152 }
58153 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58154 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58155 }
58156 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58157 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58158 }
58159 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58160 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58161 }
58162 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58163 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58164 }
58165 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58166 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58167 }
58168 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58169 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58170 }
58171 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58172 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58173 }
58174 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58175 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58176 }
58177 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58178 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58179 }
58180 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58181 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58182 }
58183 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58184 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58185 }
58186 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58187 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58188 }
58189 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58190 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58191 }
58192 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58193 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58194 }
58195 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58196 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58197 }
58198 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58199 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58200 }
58201 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58202 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58203 }
58204 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58205 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58206 }
58207 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58208 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58209 }
58210 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58211 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58212 }
58213 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58214 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58215 }
58216 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58217 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58218 }
58219 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58220 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58221 }
58222 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58223 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58224 }
58225 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58226 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58227 }
58228 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58229 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58230 }
58231 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58232 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58233 }
58234 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58235 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58236 }
58237 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58238 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58239 }
58240 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58241 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58242 }
58243 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58244 return (void *)((wxObject *) ((wxSizerItem *) x));
58245 }
58246 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58247 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58248 }
58249 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58250 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58251 }
58252 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58253 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58254 }
58255 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58256 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58257 }
58258 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58259 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58260 }
58261 static void *_p_wxSizerTo_p_wxObject(void *x) {
58262 return (void *)((wxObject *) ((wxSizer *) x));
58263 }
58264 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58265 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58266 }
58267 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58269 }
58270 static void *_p_wxEventTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) ((wxEvent *) x));
58272 }
58273 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58275 }
58276 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58278 }
58279 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58281 }
58282 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58284 }
58285 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58287 }
58288 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58290 }
58291 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58293 }
58294 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58296 }
58297 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58299 }
58300 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58302 }
58303 static void *_p_wxControlTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58305 }
58306 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58308 }
58309 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) ((wxFSFile *) x));
58311 }
58312 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58314 }
58315 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58317 }
58318 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58320 }
58321 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58323 }
58324 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) ((wxMenuItem *) x));
58326 }
58327 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58329 }
58330 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58332 }
58333 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58335 }
58336 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58338 }
58339 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58341 }
58342 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58344 }
58345 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58347 }
58348 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58350 }
58351 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58353 }
58354 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58356 }
58357 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58359 }
58360 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58362 }
58363 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58365 }
58366 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58368 }
58369 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58371 }
58372 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58374 }
58375 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58377 }
58378 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58380 }
58381 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58383 }
58384 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) ((wxImageHandler *) x));
58386 }
58387 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58389 }
58390 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58392 }
58393 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58395 }
58396 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) ((wxEvtHandler *) x));
58398 }
58399 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58401 }
58402 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58404 }
58405 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58407 }
58408 static void *_p_wxImageTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) ((wxImage *) x));
58410 }
58411 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58413 }
58414 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58416 }
58417 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58419 }
58420 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58422 }
58423 static void *_p_wxWindowTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58425 }
58426 static void *_p_wxMenuTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58428 }
58429 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58431 }
58432 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) ((wxFileSystem *) x));
58434 }
58435 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58437 }
58438 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58440 }
58441 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58443 }
58444 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58446 }
58447 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58449 }
58450 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58452 }
58453 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58454 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58455 }
58456 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58457 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58458 }
58459 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58460 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58461 }
58462 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58463 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58464 }
58465 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58467 }
58468 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58469 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58470 }
58471 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58472 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58473 }
58474 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58475 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58476 }
58477 static void *_p_wxControlTo_p_wxWindow(void *x) {
58478 return (void *)((wxWindow *) ((wxControl *) x));
58479 }
58480 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58481 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58482 }
58483 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58484 return (void *)((wxWindow *) ((wxMenuBar *) x));
58485 }
58486 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58487 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58488 }
58489 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58490 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58491 }
58492 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58493 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58494 }
58495 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58496 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58497 }
58498 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58499 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58500 }
58501 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58502 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58503 }
58504 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58505 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58506 }
58507 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58508 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58509 }
58510 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58511 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58512 }
58513 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58514 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58515 }
58516 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58517 return (void *)((wxValidator *) ((wxPyValidator *) x));
58518 }
58519 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58521 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};
58522 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58640 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58641 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58642 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58643 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58644 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58645 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58646 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58647 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58648 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58649 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58650 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58651 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58652 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58653 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58654
58655 static swig_type_info *swig_type_initial[] = {
58656 &_swigt__p_buffer,
58657 &_swigt__p_char,
58658 &_swigt__p_form_ops_t,
58659 &_swigt__p_int,
58660 &_swigt__p_long,
58661 &_swigt__p_unsigned_char,
58662 &_swigt__p_unsigned_int,
58663 &_swigt__p_unsigned_long,
58664 &_swigt__p_wxANIHandler,
58665 &_swigt__p_wxAcceleratorEntry,
58666 &_swigt__p_wxAcceleratorTable,
58667 &_swigt__p_wxActivateEvent,
58668 &_swigt__p_wxAppTraits,
58669 &_swigt__p_wxArrayString,
58670 &_swigt__p_wxBMPHandler,
58671 &_swigt__p_wxBitmap,
58672 &_swigt__p_wxBoxSizer,
58673 &_swigt__p_wxButton,
58674 &_swigt__p_wxCURHandler,
58675 &_swigt__p_wxCaret,
58676 &_swigt__p_wxChildFocusEvent,
58677 &_swigt__p_wxClipboardTextEvent,
58678 &_swigt__p_wxCloseEvent,
58679 &_swigt__p_wxColour,
58680 &_swigt__p_wxCommandEvent,
58681 &_swigt__p_wxContextMenuEvent,
58682 &_swigt__p_wxControl,
58683 &_swigt__p_wxControlWithItems,
58684 &_swigt__p_wxCursor,
58685 &_swigt__p_wxDC,
58686 &_swigt__p_wxDateEvent,
58687 &_swigt__p_wxDateTime,
58688 &_swigt__p_wxDisplayChangedEvent,
58689 &_swigt__p_wxDouble,
58690 &_swigt__p_wxDropFilesEvent,
58691 &_swigt__p_wxDuplexMode,
58692 &_swigt__p_wxEraseEvent,
58693 &_swigt__p_wxEvent,
58694 &_swigt__p_wxEventLoop,
58695 &_swigt__p_wxEventLoopActivator,
58696 &_swigt__p_wxEvtHandler,
58697 &_swigt__p_wxFSFile,
58698 &_swigt__p_wxFileSystem,
58699 &_swigt__p_wxFileSystemHandler,
58700 &_swigt__p_wxFlexGridSizer,
58701 &_swigt__p_wxFocusEvent,
58702 &_swigt__p_wxFont,
58703 &_swigt__p_wxFrame,
58704 &_swigt__p_wxGBPosition,
58705 &_swigt__p_wxGBSizerItem,
58706 &_swigt__p_wxGBSpan,
58707 &_swigt__p_wxGIFHandler,
58708 &_swigt__p_wxGridBagSizer,
58709 &_swigt__p_wxGridSizer,
58710 &_swigt__p_wxHelpEvent__Origin,
58711 &_swigt__p_wxICOHandler,
58712 &_swigt__p_wxIconizeEvent,
58713 &_swigt__p_wxIdleEvent,
58714 &_swigt__p_wxImage,
58715 &_swigt__p_wxImageHandler,
58716 &_swigt__p_wxImageHistogram,
58717 &_swigt__p_wxImage_HSVValue,
58718 &_swigt__p_wxImage_RGBValue,
58719 &_swigt__p_wxIndividualLayoutConstraint,
58720 &_swigt__p_wxInitDialogEvent,
58721 &_swigt__p_wxInputStream,
58722 &_swigt__p_wxInternetFSHandler,
58723 &_swigt__p_wxItemContainer,
58724 &_swigt__p_wxJPEGHandler,
58725 &_swigt__p_wxKeyEvent,
58726 &_swigt__p_wxLayoutConstraints,
58727 &_swigt__p_wxMaximizeEvent,
58728 &_swigt__p_wxMemoryFSHandler,
58729 &_swigt__p_wxMenu,
58730 &_swigt__p_wxMenuBar,
58731 &_swigt__p_wxMenuBarBase,
58732 &_swigt__p_wxMenuEvent,
58733 &_swigt__p_wxMenuItem,
58734 &_swigt__p_wxMouseCaptureChangedEvent,
58735 &_swigt__p_wxMouseCaptureLostEvent,
58736 &_swigt__p_wxMouseEvent,
58737 &_swigt__p_wxMoveEvent,
58738 &_swigt__p_wxNavigationKeyEvent,
58739 &_swigt__p_wxNcPaintEvent,
58740 &_swigt__p_wxNotifyEvent,
58741 &_swigt__p_wxObject,
58742 &_swigt__p_wxOutputStream,
58743 &_swigt__p_wxPCXHandler,
58744 &_swigt__p_wxPNGHandler,
58745 &_swigt__p_wxPNMHandler,
58746 &_swigt__p_wxPaintEvent,
58747 &_swigt__p_wxPaletteChangedEvent,
58748 &_swigt__p_wxPaperSize,
58749 &_swigt__p_wxPoint,
58750 &_swigt__p_wxPoint2D,
58751 &_swigt__p_wxPropagateOnce,
58752 &_swigt__p_wxPropagationDisabler,
58753 &_swigt__p_wxPyApp,
58754 &_swigt__p_wxPyCommandEvent,
58755 &_swigt__p_wxPyDropTarget,
58756 &_swigt__p_wxPyEvent,
58757 &_swigt__p_wxPyFileSystemHandler,
58758 &_swigt__p_wxPyImageHandler,
58759 &_swigt__p_wxPyInputStream,
58760 &_swigt__p_wxPySizer,
58761 &_swigt__p_wxPyValidator,
58762 &_swigt__p_wxQuantize,
58763 &_swigt__p_wxQueryNewPaletteEvent,
58764 &_swigt__p_wxRealPoint,
58765 &_swigt__p_wxRect,
58766 &_swigt__p_wxRect2D,
58767 &_swigt__p_wxRegion,
58768 &_swigt__p_wxScrollEvent,
58769 &_swigt__p_wxScrollWinEvent,
58770 &_swigt__p_wxSetCursorEvent,
58771 &_swigt__p_wxShowEvent,
58772 &_swigt__p_wxSize,
58773 &_swigt__p_wxSizeEvent,
58774 &_swigt__p_wxSizer,
58775 &_swigt__p_wxSizerItem,
58776 &_swigt__p_wxStaticBox,
58777 &_swigt__p_wxStaticBoxSizer,
58778 &_swigt__p_wxStdDialogButtonSizer,
58779 &_swigt__p_wxSysColourChangedEvent,
58780 &_swigt__p_wxTGAHandler,
58781 &_swigt__p_wxTIFFHandler,
58782 &_swigt__p_wxToolTip,
58783 &_swigt__p_wxUpdateUIEvent,
58784 &_swigt__p_wxValidator,
58785 &_swigt__p_wxVisualAttributes,
58786 &_swigt__p_wxWindow,
58787 &_swigt__p_wxWindowCreateEvent,
58788 &_swigt__p_wxWindowDestroyEvent,
58789 &_swigt__p_wxXPMHandler,
58790 &_swigt__p_wxZipFSHandler,
58791 };
58792
58793 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58794 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58807 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}};
58808 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58809 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}};
58810 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58811 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}};
58812 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58817 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}};
58818 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58819 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}};
58820 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58830 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}};
58831 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58833 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}};
58834 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58836 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}};
58837 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}};
58838 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58846 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}};
58847 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58848 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}};
58849 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_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}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58860 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}};
58861 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58864 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58865 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58878 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_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_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_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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_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}};
58879 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58880 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58886 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58887 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58896 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58897 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58898 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58905 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58906 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58907 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58908 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58911 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}};
58912 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}};
58913 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58914 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58915 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58916 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58917 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58918 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58919 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58920 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58921 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}};
58922 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58923 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}};
58924 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58925 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58926 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58927 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58928
58929 static swig_cast_info *swig_cast_initial[] = {
58930 _swigc__p_buffer,
58931 _swigc__p_char,
58932 _swigc__p_form_ops_t,
58933 _swigc__p_int,
58934 _swigc__p_long,
58935 _swigc__p_unsigned_char,
58936 _swigc__p_unsigned_int,
58937 _swigc__p_unsigned_long,
58938 _swigc__p_wxANIHandler,
58939 _swigc__p_wxAcceleratorEntry,
58940 _swigc__p_wxAcceleratorTable,
58941 _swigc__p_wxActivateEvent,
58942 _swigc__p_wxAppTraits,
58943 _swigc__p_wxArrayString,
58944 _swigc__p_wxBMPHandler,
58945 _swigc__p_wxBitmap,
58946 _swigc__p_wxBoxSizer,
58947 _swigc__p_wxButton,
58948 _swigc__p_wxCURHandler,
58949 _swigc__p_wxCaret,
58950 _swigc__p_wxChildFocusEvent,
58951 _swigc__p_wxClipboardTextEvent,
58952 _swigc__p_wxCloseEvent,
58953 _swigc__p_wxColour,
58954 _swigc__p_wxCommandEvent,
58955 _swigc__p_wxContextMenuEvent,
58956 _swigc__p_wxControl,
58957 _swigc__p_wxControlWithItems,
58958 _swigc__p_wxCursor,
58959 _swigc__p_wxDC,
58960 _swigc__p_wxDateEvent,
58961 _swigc__p_wxDateTime,
58962 _swigc__p_wxDisplayChangedEvent,
58963 _swigc__p_wxDouble,
58964 _swigc__p_wxDropFilesEvent,
58965 _swigc__p_wxDuplexMode,
58966 _swigc__p_wxEraseEvent,
58967 _swigc__p_wxEvent,
58968 _swigc__p_wxEventLoop,
58969 _swigc__p_wxEventLoopActivator,
58970 _swigc__p_wxEvtHandler,
58971 _swigc__p_wxFSFile,
58972 _swigc__p_wxFileSystem,
58973 _swigc__p_wxFileSystemHandler,
58974 _swigc__p_wxFlexGridSizer,
58975 _swigc__p_wxFocusEvent,
58976 _swigc__p_wxFont,
58977 _swigc__p_wxFrame,
58978 _swigc__p_wxGBPosition,
58979 _swigc__p_wxGBSizerItem,
58980 _swigc__p_wxGBSpan,
58981 _swigc__p_wxGIFHandler,
58982 _swigc__p_wxGridBagSizer,
58983 _swigc__p_wxGridSizer,
58984 _swigc__p_wxHelpEvent__Origin,
58985 _swigc__p_wxICOHandler,
58986 _swigc__p_wxIconizeEvent,
58987 _swigc__p_wxIdleEvent,
58988 _swigc__p_wxImage,
58989 _swigc__p_wxImageHandler,
58990 _swigc__p_wxImageHistogram,
58991 _swigc__p_wxImage_HSVValue,
58992 _swigc__p_wxImage_RGBValue,
58993 _swigc__p_wxIndividualLayoutConstraint,
58994 _swigc__p_wxInitDialogEvent,
58995 _swigc__p_wxInputStream,
58996 _swigc__p_wxInternetFSHandler,
58997 _swigc__p_wxItemContainer,
58998 _swigc__p_wxJPEGHandler,
58999 _swigc__p_wxKeyEvent,
59000 _swigc__p_wxLayoutConstraints,
59001 _swigc__p_wxMaximizeEvent,
59002 _swigc__p_wxMemoryFSHandler,
59003 _swigc__p_wxMenu,
59004 _swigc__p_wxMenuBar,
59005 _swigc__p_wxMenuBarBase,
59006 _swigc__p_wxMenuEvent,
59007 _swigc__p_wxMenuItem,
59008 _swigc__p_wxMouseCaptureChangedEvent,
59009 _swigc__p_wxMouseCaptureLostEvent,
59010 _swigc__p_wxMouseEvent,
59011 _swigc__p_wxMoveEvent,
59012 _swigc__p_wxNavigationKeyEvent,
59013 _swigc__p_wxNcPaintEvent,
59014 _swigc__p_wxNotifyEvent,
59015 _swigc__p_wxObject,
59016 _swigc__p_wxOutputStream,
59017 _swigc__p_wxPCXHandler,
59018 _swigc__p_wxPNGHandler,
59019 _swigc__p_wxPNMHandler,
59020 _swigc__p_wxPaintEvent,
59021 _swigc__p_wxPaletteChangedEvent,
59022 _swigc__p_wxPaperSize,
59023 _swigc__p_wxPoint,
59024 _swigc__p_wxPoint2D,
59025 _swigc__p_wxPropagateOnce,
59026 _swigc__p_wxPropagationDisabler,
59027 _swigc__p_wxPyApp,
59028 _swigc__p_wxPyCommandEvent,
59029 _swigc__p_wxPyDropTarget,
59030 _swigc__p_wxPyEvent,
59031 _swigc__p_wxPyFileSystemHandler,
59032 _swigc__p_wxPyImageHandler,
59033 _swigc__p_wxPyInputStream,
59034 _swigc__p_wxPySizer,
59035 _swigc__p_wxPyValidator,
59036 _swigc__p_wxQuantize,
59037 _swigc__p_wxQueryNewPaletteEvent,
59038 _swigc__p_wxRealPoint,
59039 _swigc__p_wxRect,
59040 _swigc__p_wxRect2D,
59041 _swigc__p_wxRegion,
59042 _swigc__p_wxScrollEvent,
59043 _swigc__p_wxScrollWinEvent,
59044 _swigc__p_wxSetCursorEvent,
59045 _swigc__p_wxShowEvent,
59046 _swigc__p_wxSize,
59047 _swigc__p_wxSizeEvent,
59048 _swigc__p_wxSizer,
59049 _swigc__p_wxSizerItem,
59050 _swigc__p_wxStaticBox,
59051 _swigc__p_wxStaticBoxSizer,
59052 _swigc__p_wxStdDialogButtonSizer,
59053 _swigc__p_wxSysColourChangedEvent,
59054 _swigc__p_wxTGAHandler,
59055 _swigc__p_wxTIFFHandler,
59056 _swigc__p_wxToolTip,
59057 _swigc__p_wxUpdateUIEvent,
59058 _swigc__p_wxValidator,
59059 _swigc__p_wxVisualAttributes,
59060 _swigc__p_wxWindow,
59061 _swigc__p_wxWindowCreateEvent,
59062 _swigc__p_wxWindowDestroyEvent,
59063 _swigc__p_wxXPMHandler,
59064 _swigc__p_wxZipFSHandler,
59065 };
59066
59067
59068 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59069
59070 static swig_const_info swig_const_table[] = {
59071 {0, 0, 0, 0.0, 0, 0}};
59072
59073 #ifdef __cplusplus
59074 }
59075 #endif
59076 /* -----------------------------------------------------------------------------
59077 * Type initialization:
59078 * This problem is tough by the requirement that no dynamic
59079 * memory is used. Also, since swig_type_info structures store pointers to
59080 * swig_cast_info structures and swig_cast_info structures store pointers back
59081 * to swig_type_info structures, we need some lookup code at initialization.
59082 * The idea is that swig generates all the structures that are needed.
59083 * The runtime then collects these partially filled structures.
59084 * The SWIG_InitializeModule function takes these initial arrays out of
59085 * swig_module, and does all the lookup, filling in the swig_module.types
59086 * array with the correct data and linking the correct swig_cast_info
59087 * structures together.
59088 *
59089 * The generated swig_type_info structures are assigned staticly to an initial
59090 * array. We just loop though that array, and handle each type individually.
59091 * First we lookup if this type has been already loaded, and if so, use the
59092 * loaded structure instead of the generated one. Then we have to fill in the
59093 * cast linked list. The cast data is initially stored in something like a
59094 * two-dimensional array. Each row corresponds to a type (there are the same
59095 * number of rows as there are in the swig_type_initial array). Each entry in
59096 * a column is one of the swig_cast_info structures for that type.
59097 * The cast_initial array is actually an array of arrays, because each row has
59098 * a variable number of columns. So to actually build the cast linked list,
59099 * we find the array of casts associated with the type, and loop through it
59100 * adding the casts to the list. The one last trick we need to do is making
59101 * sure the type pointer in the swig_cast_info struct is correct.
59102 *
59103 * First off, we lookup the cast->type name to see if it is already loaded.
59104 * There are three cases to handle:
59105 * 1) If the cast->type has already been loaded AND the type we are adding
59106 * casting info to has not been loaded (it is in this module), THEN we
59107 * replace the cast->type pointer with the type pointer that has already
59108 * been loaded.
59109 * 2) If BOTH types (the one we are adding casting info to, and the
59110 * cast->type) are loaded, THEN the cast info has already been loaded by
59111 * the previous module so we just ignore it.
59112 * 3) Finally, if cast->type has not already been loaded, then we add that
59113 * swig_cast_info to the linked list (because the cast->type) pointer will
59114 * be correct.
59115 * ----------------------------------------------------------------------------- */
59116
59117 #ifdef __cplusplus
59118 extern "C" {
59119 #if 0
59120 } /* c-mode */
59121 #endif
59122 #endif
59123
59124 #if 0
59125 #define SWIGRUNTIME_DEBUG
59126 #endif
59127
59128 SWIGRUNTIME void
59129 SWIG_InitializeModule(void *clientdata) {
59130 size_t i;
59131 swig_module_info *module_head;
59132 static int init_run = 0;
59133
59134 clientdata = clientdata;
59135
59136 if (init_run) return;
59137 init_run = 1;
59138
59139 /* Initialize the swig_module */
59140 swig_module.type_initial = swig_type_initial;
59141 swig_module.cast_initial = swig_cast_initial;
59142
59143 /* Try and load any already created modules */
59144 module_head = SWIG_GetModule(clientdata);
59145 if (module_head) {
59146 swig_module.next = module_head->next;
59147 module_head->next = &swig_module;
59148 } else {
59149 /* This is the first module loaded */
59150 swig_module.next = &swig_module;
59151 SWIG_SetModule(clientdata, &swig_module);
59152 }
59153
59154 /* Now work on filling in swig_module.types */
59155 #ifdef SWIGRUNTIME_DEBUG
59156 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59157 #endif
59158 for (i = 0; i < swig_module.size; ++i) {
59159 swig_type_info *type = 0;
59160 swig_type_info *ret;
59161 swig_cast_info *cast;
59162
59163 #ifdef SWIGRUNTIME_DEBUG
59164 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59165 #endif
59166
59167 /* if there is another module already loaded */
59168 if (swig_module.next != &swig_module) {
59169 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59170 }
59171 if (type) {
59172 /* Overwrite clientdata field */
59173 #ifdef SWIGRUNTIME_DEBUG
59174 printf("SWIG_InitializeModule: found type %s\n", type->name);
59175 #endif
59176 if (swig_module.type_initial[i]->clientdata) {
59177 type->clientdata = swig_module.type_initial[i]->clientdata;
59178 #ifdef SWIGRUNTIME_DEBUG
59179 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59180 #endif
59181 }
59182 } else {
59183 type = swig_module.type_initial[i];
59184 }
59185
59186 /* Insert casting types */
59187 cast = swig_module.cast_initial[i];
59188 while (cast->type) {
59189 /* Don't need to add information already in the list */
59190 ret = 0;
59191 #ifdef SWIGRUNTIME_DEBUG
59192 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59193 #endif
59194 if (swig_module.next != &swig_module) {
59195 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59196 #ifdef SWIGRUNTIME_DEBUG
59197 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59198 #endif
59199 }
59200 if (ret) {
59201 if (type == swig_module.type_initial[i]) {
59202 #ifdef SWIGRUNTIME_DEBUG
59203 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59204 #endif
59205 cast->type = ret;
59206 ret = 0;
59207 } else {
59208 /* Check for casting already in the list */
59209 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59210 #ifdef SWIGRUNTIME_DEBUG
59211 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59212 #endif
59213 if (!ocast) ret = 0;
59214 }
59215 }
59216
59217 if (!ret) {
59218 #ifdef SWIGRUNTIME_DEBUG
59219 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59220 #endif
59221 if (type->cast) {
59222 type->cast->prev = cast;
59223 cast->next = type->cast;
59224 }
59225 type->cast = cast;
59226 }
59227 cast++;
59228 }
59229 /* Set entry in modules->types array equal to the type */
59230 swig_module.types[i] = type;
59231 }
59232 swig_module.types[i] = 0;
59233
59234 #ifdef SWIGRUNTIME_DEBUG
59235 printf("**** SWIG_InitializeModule: Cast List ******\n");
59236 for (i = 0; i < swig_module.size; ++i) {
59237 int j = 0;
59238 swig_cast_info *cast = swig_module.cast_initial[i];
59239 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59240 while (cast->type) {
59241 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59242 cast++;
59243 ++j;
59244 }
59245 printf("---- Total casts: %d\n",j);
59246 }
59247 printf("**** SWIG_InitializeModule: Cast List ******\n");
59248 #endif
59249 }
59250
59251 /* This function will propagate the clientdata field of type to
59252 * any new swig_type_info structures that have been added into the list
59253 * of equivalent types. It is like calling
59254 * SWIG_TypeClientData(type, clientdata) a second time.
59255 */
59256 SWIGRUNTIME void
59257 SWIG_PropagateClientData(void) {
59258 size_t i;
59259 swig_cast_info *equiv;
59260 static int init_run = 0;
59261
59262 if (init_run) return;
59263 init_run = 1;
59264
59265 for (i = 0; i < swig_module.size; i++) {
59266 if (swig_module.types[i]->clientdata) {
59267 equiv = swig_module.types[i]->cast;
59268 while (equiv) {
59269 if (!equiv->converter) {
59270 if (equiv->type && !equiv->type->clientdata)
59271 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59272 }
59273 equiv = equiv->next;
59274 }
59275 }
59276 }
59277 }
59278
59279 #ifdef __cplusplus
59280 #if 0
59281 {
59282 /* c-mode */
59283 #endif
59284 }
59285 #endif
59286
59287
59288
59289 #ifdef __cplusplus
59290 extern "C" {
59291 #endif
59292
59293 /* Python-specific SWIG API */
59294 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59295 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59296 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59297
59298 /* -----------------------------------------------------------------------------
59299 * global variable support code.
59300 * ----------------------------------------------------------------------------- */
59301
59302 typedef struct swig_globalvar {
59303 char *name; /* Name of global variable */
59304 PyObject *(*get_attr)(void); /* Return the current value */
59305 int (*set_attr)(PyObject *); /* Set the value */
59306 struct swig_globalvar *next;
59307 } swig_globalvar;
59308
59309 typedef struct swig_varlinkobject {
59310 PyObject_HEAD
59311 swig_globalvar *vars;
59312 } swig_varlinkobject;
59313
59314 SWIGINTERN PyObject *
59315 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59316 return PyString_FromString("<Swig global variables>");
59317 }
59318
59319 SWIGINTERN PyObject *
59320 swig_varlink_str(swig_varlinkobject *v) {
59321 PyObject *str = PyString_FromString("(");
59322 swig_globalvar *var;
59323 for (var = v->vars; var; var=var->next) {
59324 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59325 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59326 }
59327 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59328 return str;
59329 }
59330
59331 SWIGINTERN int
59332 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59333 PyObject *str = swig_varlink_str(v);
59334 fprintf(fp,"Swig global variables ");
59335 fprintf(fp,"%s\n", PyString_AsString(str));
59336 Py_DECREF(str);
59337 return 0;
59338 }
59339
59340 SWIGINTERN void
59341 swig_varlink_dealloc(swig_varlinkobject *v) {
59342 swig_globalvar *var = v->vars;
59343 while (var) {
59344 swig_globalvar *n = var->next;
59345 free(var->name);
59346 free(var);
59347 var = n;
59348 }
59349 }
59350
59351 SWIGINTERN PyObject *
59352 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59353 PyObject *res = NULL;
59354 swig_globalvar *var = v->vars;
59355 while (var) {
59356 if (strcmp(var->name,n) == 0) {
59357 res = (*var->get_attr)();
59358 break;
59359 }
59360 var = var->next;
59361 }
59362 if (res == NULL && !PyErr_Occurred()) {
59363 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59364 }
59365 return res;
59366 }
59367
59368 SWIGINTERN int
59369 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59370 int res = 1;
59371 swig_globalvar *var = v->vars;
59372 while (var) {
59373 if (strcmp(var->name,n) == 0) {
59374 res = (*var->set_attr)(p);
59375 break;
59376 }
59377 var = var->next;
59378 }
59379 if (res == 1 && !PyErr_Occurred()) {
59380 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59381 }
59382 return res;
59383 }
59384
59385 SWIGINTERN PyTypeObject*
59386 swig_varlink_type(void) {
59387 static char varlink__doc__[] = "Swig var link object";
59388 static PyTypeObject varlink_type;
59389 static int type_init = 0;
59390 if (!type_init) {
59391 const PyTypeObject tmp
59392 = {
59393 PyObject_HEAD_INIT(NULL)
59394 0, /* Number of items in variable part (ob_size) */
59395 (char *)"swigvarlink", /* Type name (tp_name) */
59396 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59397 0, /* Itemsize (tp_itemsize) */
59398 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59399 (printfunc) swig_varlink_print, /* Print (tp_print) */
59400 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59401 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59402 0, /* tp_compare */
59403 (reprfunc) swig_varlink_repr, /* tp_repr */
59404 0, /* tp_as_number */
59405 0, /* tp_as_sequence */
59406 0, /* tp_as_mapping */
59407 0, /* tp_hash */
59408 0, /* tp_call */
59409 (reprfunc)swig_varlink_str, /* tp_str */
59410 0, /* tp_getattro */
59411 0, /* tp_setattro */
59412 0, /* tp_as_buffer */
59413 0, /* tp_flags */
59414 varlink__doc__, /* tp_doc */
59415 0, /* tp_traverse */
59416 0, /* tp_clear */
59417 0, /* tp_richcompare */
59418 0, /* tp_weaklistoffset */
59419 #if PY_VERSION_HEX >= 0x02020000
59420 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59421 #endif
59422 #if PY_VERSION_HEX >= 0x02030000
59423 0, /* tp_del */
59424 #endif
59425 #ifdef COUNT_ALLOCS
59426 0,0,0,0 /* tp_alloc -> tp_next */
59427 #endif
59428 };
59429 varlink_type = tmp;
59430 varlink_type.ob_type = &PyType_Type;
59431 type_init = 1;
59432 }
59433 return &varlink_type;
59434 }
59435
59436 /* Create a variable linking object for use later */
59437 SWIGINTERN PyObject *
59438 SWIG_Python_newvarlink(void) {
59439 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59440 if (result) {
59441 result->vars = 0;
59442 }
59443 return ((PyObject*) result);
59444 }
59445
59446 SWIGINTERN void
59447 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59448 swig_varlinkobject *v = (swig_varlinkobject *) p;
59449 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59450 if (gv) {
59451 size_t size = strlen(name)+1;
59452 gv->name = (char *)malloc(size);
59453 if (gv->name) {
59454 strncpy(gv->name,name,size);
59455 gv->get_attr = get_attr;
59456 gv->set_attr = set_attr;
59457 gv->next = v->vars;
59458 }
59459 }
59460 v->vars = gv;
59461 }
59462
59463 SWIGINTERN PyObject *
59464 SWIG_globals() {
59465 static PyObject *_SWIG_globals = 0;
59466 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59467 return _SWIG_globals;
59468 }
59469
59470 /* -----------------------------------------------------------------------------
59471 * constants/methods manipulation
59472 * ----------------------------------------------------------------------------- */
59473
59474 /* Install Constants */
59475 SWIGINTERN void
59476 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59477 PyObject *obj = 0;
59478 size_t i;
59479 for (i = 0; constants[i].type; ++i) {
59480 switch(constants[i].type) {
59481 case SWIG_PY_POINTER:
59482 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59483 break;
59484 case SWIG_PY_BINARY:
59485 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59486 break;
59487 default:
59488 obj = 0;
59489 break;
59490 }
59491 if (obj) {
59492 PyDict_SetItemString(d, constants[i].name, obj);
59493 Py_DECREF(obj);
59494 }
59495 }
59496 }
59497
59498 /* -----------------------------------------------------------------------------*/
59499 /* Fix SwigMethods to carry the callback ptrs when needed */
59500 /* -----------------------------------------------------------------------------*/
59501
59502 SWIGINTERN void
59503 SWIG_Python_FixMethods(PyMethodDef *methods,
59504 swig_const_info *const_table,
59505 swig_type_info **types,
59506 swig_type_info **types_initial) {
59507 size_t i;
59508 for (i = 0; methods[i].ml_name; ++i) {
59509 const char *c = methods[i].ml_doc;
59510 if (c && (c = strstr(c, "swig_ptr: "))) {
59511 int j;
59512 swig_const_info *ci = 0;
59513 const char *name = c + 10;
59514 for (j = 0; const_table[j].type; ++j) {
59515 if (strncmp(const_table[j].name, name,
59516 strlen(const_table[j].name)) == 0) {
59517 ci = &(const_table[j]);
59518 break;
59519 }
59520 }
59521 if (ci) {
59522 size_t shift = (ci->ptype) - types;
59523 swig_type_info *ty = types_initial[shift];
59524 size_t ldoc = (c - methods[i].ml_doc);
59525 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59526 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59527 if (ndoc) {
59528 char *buff = ndoc;
59529 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59530 if (ptr) {
59531 strncpy(buff, methods[i].ml_doc, ldoc);
59532 buff += ldoc;
59533 strncpy(buff, "swig_ptr: ", 10);
59534 buff += 10;
59535 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59536 methods[i].ml_doc = ndoc;
59537 }
59538 }
59539 }
59540 }
59541 }
59542 }
59543
59544 #ifdef __cplusplus
59545 }
59546 #endif
59547
59548 /* -----------------------------------------------------------------------------*
59549 * Partial Init method
59550 * -----------------------------------------------------------------------------*/
59551
59552 #ifdef __cplusplus
59553 extern "C"
59554 #endif
59555 SWIGEXPORT void SWIG_init(void) {
59556 PyObject *m, *d;
59557
59558 /* Fix SwigMethods to carry the callback ptrs when needed */
59559 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59560
59561 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59562 d = PyModule_GetDict(m);
59563
59564 SWIG_InitializeModule(0);
59565 SWIG_InstallConstants(d,swig_const_table);
59566
59567
59568
59569 #ifndef wxPyUSE_EXPORT
59570 // Make our API structure a CObject so other modules can import it
59571 // from this module.
59572 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59573 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59574 Py_XDECREF(cobj);
59575 #endif
59576
59577 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59578 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59579 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59580 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59581 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59582 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59583 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59584 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59585 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59586 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59587 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59588 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59589 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59590 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59591 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59592 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59593 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59594 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59595 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59596 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59597 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59598 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59599 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59600 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59601 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59602 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59603 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59604 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59605 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59606 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59607 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59608 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59609 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59610 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59611 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59612 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59613 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59614 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59615 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59616 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59617 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59618 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59619 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59620 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59621 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59622 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59623 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59624 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59625 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59626 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59627 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59628 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59629 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59630 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59631 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59632 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59633 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59634 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59635 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59636 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59637 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59638 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59639 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59640 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59641 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59642 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59643 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59644 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59645 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59646 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59647 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59648 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59649 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59650 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59651 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59652 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59653 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59654 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59655 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59656 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59657 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59658 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59659 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59660 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59661 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59662 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59663 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59664 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59665 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59666 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59667 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59668 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59669 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59670 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59671 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59672 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59673 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59674 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59675 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59676 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59677 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59678 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59679 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59680 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59681 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59682 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59683 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59684 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59685 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59686 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59687 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59688 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59689 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59690 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59691 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59692 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59693 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59694 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59695 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59696 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59697 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59698 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59699 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59700 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59701 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59702 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59703 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59704 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59705 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59706 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59707 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59708 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59709 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59710 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59711 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59712 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59713 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59714 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59715 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59716 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59717 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59718 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59719 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59720 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59721 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59722 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59723 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59724 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59725 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59726 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59727 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59728 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59729 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59730 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59731 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59732 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59733 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59734 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59735 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59736 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59737 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59738 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59739 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59740 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59741 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59742 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59743 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59744 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59745 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59746 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59747 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59748 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59749 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59750 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59751 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59752 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59753 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59754 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59755 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59756 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59757 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59758 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59759 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59760 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59761 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59762 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59763 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59764 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59765 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59766 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59767 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59768 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59769 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59770 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59771 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59772 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59773 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59774 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59775 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59776 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59777 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59778 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59779 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59780 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59781 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59782 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59783 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59784 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59785 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59786 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59787 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59788 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59789 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59790 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59791 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59792 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59793 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59794 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59795 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59796 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59797 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59798 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59799 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59800 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59801 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59802 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59803 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59804 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59805 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59806 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59807 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59808 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59809 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59810 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59811 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59812 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59813 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59814 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59815 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59816 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59817 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59818 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59819 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59820 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59821 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59822 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59823 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59824 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59825 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59826 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59827 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59828 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59829 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59830 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59831 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59832 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59833 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59834 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59835 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59836 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59837 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59838 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59839 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59840 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59841 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59842 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59843 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59844 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59845 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59846 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59847 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59848 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59849 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59850 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59851 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59852 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59853 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59854 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59855 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59856 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59857 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59858 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59859 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59860 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59861 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59862 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59863 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59864 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59865 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59866 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59867 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59868 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59869 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59870 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59871 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59872 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59873 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59874 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59875 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59876 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59877 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59878 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59879 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59880 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59881 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59882 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59883 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59884 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59885 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59886 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59887 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59888 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59889 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59890 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59891 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59892 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59893 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59894 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59895 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59896 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59897 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59898 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59899 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59900 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59901 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59902 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59903 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59904 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59905 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59906 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59907 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59908 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59909 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59910 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59911 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59912 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59913 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59914 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59915 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59916 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59917 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59918 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59919 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59920 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59921 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59922 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59923 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59924 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59925 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59926 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59927 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59928 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59929 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59930 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59931 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59932 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59933 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59934 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59935 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59936 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59937 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59938 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59939 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59940 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59941 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59942 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59943 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59944 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59945 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59946 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59947 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59948 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59949 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59950 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59951 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59952 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59953 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59954 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59955 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59956 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59957 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59958 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59959 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59960 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59961 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59962 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59963 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59964 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59965 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59966 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59967 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59968 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59969 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59970 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59978 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59985 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59986 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59987 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59988 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59998 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59999 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60000 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60001 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60002 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60003 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60004 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60005 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60006 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60007 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60008 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60009 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60010 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60011 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60012 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60013 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60014 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60015 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60016 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60017 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60018 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60019 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60020 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60021 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60022 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60023 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60024 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60025 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60026 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60027 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60028 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60029 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60030 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60031 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60032 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60033 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60034 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60035 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60036 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60037 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60038 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60039 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60040 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60041 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60042 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60043 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60044 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60045 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60046 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60047 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60048 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60049 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60050 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60051 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60052 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60053 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60054 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60055 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60056 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60057 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60058 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60059 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60060 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60061 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60062 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60063 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60064 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60065 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60066 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60067 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60068 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60069 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60070 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60071 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60072 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60073 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60074 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60075 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60076 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60077 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60078 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60079 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60080 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60081 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60082 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60083 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60084 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60085 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60086 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60087 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60088 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60089 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60090 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60091 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60092 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60093 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60094 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60095 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60096 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60097 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60098 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60099 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60100 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60101 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60102 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60103 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60104 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60105 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60106 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60107 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60108 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60109 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60110 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60111 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60112 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60113 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60114 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60115 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60116 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60117 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60118 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60119 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60120 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60121 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60122 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60123 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60124 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60125 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60126 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60127 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60128 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60129 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60130 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60131 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60132 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60133 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60134 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60135 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60136 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60137 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60138 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60139 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60140 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60141 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60142 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60143 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60144 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60145 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60146 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60147 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60148 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60149 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60150 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60151 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60152 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60153 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60154 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60155 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60156 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60157 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60158 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60159 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60160 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60161 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60162 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60163 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60164 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60165 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60166 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60167 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60168 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60169 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60170 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60171 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60172 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60173 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60174 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60175 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60176 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60177 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60178 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60179 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60180 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60181 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60182 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60183 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60184 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60185 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60188 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60189 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60190 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60191 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60192 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60193 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60194 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60195 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60196 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60197 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60200 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60201 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60202 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60203 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60204 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60205 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60206 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60207 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60208 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60209 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60210 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60211 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60212 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60213 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60214 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60215 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60216 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60217 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60218 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60219 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60220 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60221 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60222 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60223 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60224 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60225 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60226 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60227 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60228 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60229 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60230 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60231 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60232 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60233 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60234 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60235 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60236 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60237 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60238 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60239 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60240 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60241 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60242
60243 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60244
60245
60246 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60247
60248 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60249 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60250 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60251 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60252 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60253 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60257 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60258 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60259 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60260 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60261 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60262 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60263 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60264 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60265 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60266 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60267 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60268 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60269 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60270 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60271 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60272 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60273 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60274 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60275 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60276 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60277 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60278 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60279 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60280 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60281 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60282 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60283 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60284 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60285 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60286 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60287 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60288 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60289 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60290 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60291 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60292 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60293 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60294 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60295 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60296 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60297 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60298 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60299 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60300 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60301 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60302 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60303 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60304 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60305 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60306 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60307 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60308 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60309 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60310 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60311 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60312 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60313 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60314 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60315 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60316 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60317 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60318 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60319 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60320 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60321 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60322 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60323 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60324 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60325 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60326 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60327 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60328 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60329 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60330 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60331 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60332 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60333 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60334 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60335 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60336 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60337 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60338 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60339 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60340 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60341 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60342 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60343 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60344 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60345 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60346 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60347 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60348 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60349 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60352 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60353 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60354 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60355 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60356 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60357 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60358 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60359 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60360 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60361 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60362 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60363 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60364 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60365 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60366 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60367 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60368 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60369 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60370 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60371 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60372 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60373 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60374 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60375 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60376 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60377 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60378 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60379 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60380 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60381 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60382 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60383 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60384 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60385 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60386 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60387 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60388 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60389 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60390 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60391 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60392 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60393 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60394 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60395 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60396 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60397 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60398 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60399 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60400 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60401 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60402 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60403 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60404 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60405 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60406 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60407 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60408 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60409 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60410 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60411 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60412 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60413 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60414 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60415 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60416 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60417 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60418 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60419 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60420 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60421 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60422 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60423 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60424 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60425 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60426 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60427 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60428 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60429 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60430 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60431 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60432 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60433 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60434 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60435 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60436 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60437 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60438 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60439 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60440 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60441 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60442 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60443 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60444 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60445 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60446 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60447 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60448 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60449 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60450 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60451 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60452 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60453 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60454 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60455 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60456 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60457 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60458 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60459 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60460 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60461 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60462
60463 // Initialize threading, some globals and such
60464 __wxPyPreStart(d);
60465
60466
60467 // Although these are defined in __version__ they need to be here too so
60468 // that an assert can be done to ensure that the wxPython and the wxWindows
60469 // versions match.
60470 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60471 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60472 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60473
60474 }
60475
wxWidgets (Impactor)